Abort::usage = "Abort[ ] generates an interrupt to abort a computation."
$Aborted::usage = "$Aborted is a special symbol that is returned as the result from a calculation that has been aborted."
AbortProtect::usage = "AbortProtect[expr] evaluates expr, saving any aborts until the evaluation is complete, or until CheckAbort is called."
Above::usage = "Above is used to specify alignment in printforms such as ColumnForm and TableForm."
Abs::usage = "Abs[z] gives the absolute value of the real or complex number z."
AbsoluteDashing::usage = "AbsoluteDashing[{d1, d2, ...}] is a two-dimensional graphics directive which specifies that lines which follow are to be drawn dashed, with successive segments having absolute lengths d1, d2, ... (repeated cyclically). The lengths di are given in points."
AbsolutePointSize::usage = "AbsolutePointSize[d] is a graphics directive which specifies that points which follow are to be shown if possible as circular regions with absolute radius d. The radius d is given in points."
AbsoluteThickness::usage = "AbsoluteThickness[d] is a graphics directive which specifies that lines which follow are to be drawn with absolute thickness d. The thickness d is given in points."
AbsoluteTime::usage = "AbsoluteTime[ ] gives the total number of seconds since the beginning of January 1, 1900, in your time zone."
AccountingForm::usage = "AccountingForm[expr] prints with all numbers in expr given in standard accounting notation."
Accumulate::usage = "Accumulate is an obsolete function, superseded by FoldList.\n Accumulate[f, g[e1, e2, ...]] gives g[e1, f[e1, e2], f[f[e1, e2], e3], ...]."
Accuracy::usage = "Accuracy[x] gives the number of digits to the right of the decimal point in the number x."
AccuracyGoal::usage = "AccuracyGoal is an option for various numerical operations which specifies how many digits of accuracy should be sought in the final result. The error is considered acceptable and the result is returned when either the AccuracyGoal or the PrecisionGoal is achieved. AccuracyGoal -> Automatic yields an accuracy goal equal to 10 digits less than the setting for WorkingPrecision. With AccuracyGoal -> Infinity, accuracy is not used as the criterion for terminating the numerical procedure. Even though you specify AccuracyGoal -> n, the results you get may have much less than n-digit accuracy."
AddTo::usage = "x += dx adds dx to x and returns the new value of x."
AiryAi::usage = "AiryAi[z] gives the Airy function Ai(z)."
AiryAiPrime::usage = "AiryAiPrime[z] gives the derivative of the Airy function Ai'(z)."
AiryBi::usage = "AiryBi[z] gives the Airy function Bi(z)."
AiryBiPrime::usage = "AiryBiPrime[z] gives the derivative of the Airy function Bi'(z)."
AlgebraicRules::usage = "AlgebraicRules[eqns, {x1, x2, ...}] generates a set of algebraic rules which replace variables earlier in the list of xi with ones later in the list, according to the equation or equations eqns."
AlgebraicRulesData::usage = "AlgebraicRulesData is an object returned by AlgebraicRules. Its OutputForm appears to be a list of rules, but the rules will be used algebraically rather than syntactically by Replace and related functions."
Alias::usage = "Alias is an obsolete function, superseded by $Pre and $PreRead."
All::usage = "All is a setting used for certain options."
Alternatives::usage = "p1 | p2 | ... is a pattern object which represents any of the patterns pi."
AmbientLight::usage = "AmbientLight is an option to Graphics3D and related functions that gives the level of simulated ambient illumination in a three-dimensional picture. The setting must be a GrayLevel, Hue, or RGBColor directive."
Analytic::usage = "Analytic is an option for Limit and Series. With Analytic -> True, unrecognized functions are treated as analytic, and processed using Taylor series expansions; with Analytic -> False, Taylor series are not used unless the function is recognized as analytic."
AnchoredSearch::usage = "AnchoredSearch is an option for Find and FindList. With AnchoredSearch -> True, the text searched for must be at the beginning of a record; with AnchoredSearch -> False, the text searched for can be anywhere in a record."
And::usage = "e1 && e2 && ... is the logical AND function. It evaluates its arguments in order, giving False immediately if any of them are False, and True if they are all True."
Apart::usage = "Apart[expr] rewrites a rational expression as a sum of terms with minimal denominators. Apart[expr, var] treats all variables other than var as constants."
ApartSquareFree::usage = "ApartSquareFree[expr, var] writes expr as a sum of terms with square-free denominators in the variable var."
Append::usage = "Append[expr, elem] gives expr with elem appended."
AppendTo::usage = "AppendTo[s, elem] appends elem to the value of s, and resets s to the result."
Apply::usage = "Apply[f, expr] or f @@ expr replaces the head of expr by f. Apply[f, expr, levelspec] replaces heads in parts of expr specified by levelspec."
ArcCos::usage = "ArcCos[z] gives the arc cosine of the complex number z."
ArcCosh::usage = "ArcCosh[z] gives the inverse hyperbolic cosine of the complex number z."
ArcCot::usage = "ArcCot[z] gives the arc cotangent of the complex number z."
ArcCoth::usage = "ArcCoth[z] gives the inverse hyperbolic cotangent of the complex number z."
ArcCsc::usage = "ArcCsc[z] gives the arc cosecant of the complex number z."
ArcCsch::usage = "ArcCsch[z] gives the inverse hyperbolic cosecant of the complex number z."
ArcSec::usage = "ArcSec[z] gives the arc secant of the complex number z."
ArcSech::usage = "ArcSech[z] gives the inverse hyperbolic secant of the complex number z."
ArcSin::usage = "ArcSin[z] gives the arc sine of the complex number z."
ArcSinh::usage = "ArcSinh[z] gives the inverse hyperbolic sine of the complex number z."
ArcTan::usage = "ArcTan[z] gives the inverse tangent of z. ArcTan[x, y] gives the inverse tangent of y/x where x and y are real, taking into account which quadrant the point (x, y) is in."
ArcTanh::usage = "ArcTanh[z] gives the inverse hyperbolic tangent of the complex number z."
Arg::usage = "Arg[z] gives the argument of the complex number z."
ArithmeticGeometricMean::usage = "ArithmeticGeometricMean[a, b] gives the arithmetic-geometric mean of a and b."
Array::usage = "Array[f, n] generates a list of length n, with elements f[i]. Array[f, {n1, n2, ...}] generates an n1 X n2 X ... array of nested lists, with elements f[i1, i2, ...]. Array[f, dims, origin] generates a list using the specified index origin (default 1). Array[f, dims, origin, h] uses head h, rather than List, for each level of the array."
AspectRatio::usage = "AspectRatio is an option for Show and related functions. With AspectRatio -> Automatic, the ratio of height to width of the plot is determined from the actual coordinate values in the plot. AspectRatio -> r makes the ratio equal to r."
AtomQ::usage = "AtomQ[expr] yields True if expr is an expression which cannot be divided into subexpressions, and yields False otherwise."
Attributes::usage = "Attributes[symbol] gives the list of attributes for a symbol."
$AutoLoad::usage = "$AutoLoad = True enables the autoloading of system packages. Small memory systems may wish to set $AutoLoad = False."
Automatic::usage = "Automatic represents an option value that is to be chosen automatically by a built-in function."
Auxiliary::usage = "Auxiliary[v] is used by the Solve package to indicate that the variable v is to be used by Roots for producing solutions, but that the corresponding values of v are not to be included in the final answer."
Axes::usage = "Axes is an option for graphics functions. With Axes -> True, all axes are drawn. Axes -> False draws no axes. Axes -> {False, True} draws a y axis but no x axis in two dimensions. Axes -> {False, False, True} draws a z axis but no x or y axis in three dimensions."
AxesEdge::usage = "AxesEdge is an option for 3D graphics functions. AxesEdge -> {{xdir, ydir}, {xdir, zdir}, {xdir, ydir}} specifies on which three edges of the bounding box axes are drawn. The idir must be either +1 or -1, and specify whether axes are drawn on the edge of the box with a larger or smaller value of coordinate i, respectively. Any pair {idir, jdir} can be replaced by Automatic or None. The default setting is AxesEdge -> Automatic. "
AxesLabel::usage = "AxesLabel is an option for graphics functions. With AxesLabel -> None, no labels are drawn on the axes in the plot. AxesLabel -> label specifies a label for the y axis of a two-dimensional plot, and the z axis of a three-dimensional plot. AxesLabel -> {xlabel, ylabel, ... } specifies labels for different axes."
AxesOrigin::usage = "AxesOrigin is an option for two-dimensional graphics functions. AxesOrigin -> {x, y} specifies that the axes drawn should cross at the point {x, y}. AxesOrigin -> Automatic uses an internal algorithm to determine where the axes should cross."
AxesStyle::usage = "AxesStyle is an option for graphics functions. AxesStyle -> style specifies that all axes are to be rendered with the specified graphics directive, or list of graphics directives. AxesStyle -> {{xstyle}, {ystyle}, ... } specifies that axes should use graphics directives xstyle, ... ."
Background::usage = "Background is an option for graphics functions which specifies the background color to use. A setting must be a CMYKColor, GrayLevel, Hue or RGBColor directive. The default setting Background -> Automatic produces a white background on most output devices."
BaseForm::usage = "BaseForm[expr, n] prints with the numbers in expr given in base n."
$BatchInput::usage = "$BatchInput is True if input in the current session is being fed directly to the Mathematica kernel in batch mode."
$BatchOutput::usage = "$BatchOutput is True if output in the current session is being sent in batch mode, suitable for reading by other programs."
Begin::usage = "Begin[\"context`\"] resets the current context."
BeginPackage::usage = "BeginPackage[\"context`\"] makes context` and System` the only active contexts. BeginPackage[\"context`\", {\"need1`\", \"need2`\", ...}] calls Needs on the needi."
Below::usage = "Below is used to specify alignment in printforms such as ColumnForm and TableForm."
BernoulliB::usage = "BernoulliB[n] gives the nth Bernoulli number. BernoulliB[n, x] gives the nth Bernoulli polynomial."
BesselI::usage = "BesselI[n, z] gives the modified Bessel function of the first kind I(n, z)."
BesselJ::usage = "BesselJ[n, z] gives the Bessel function of the first kind J(n, z)."
BesselK::usage = "BesselK[n, z] gives the modified Bessel function of the second kind K(n, z)."
BesselY::usage = "BesselY[n, z] gives the Bessel function of the second kind Y(n, z)."
Beta::usage = "Beta[a, b] gives the Euler beta function B(a, b). Beta[z, a, b] gives the incomplete beta function. Beta[z0, z1, a, b] gives the generalized incomplete Beta function Beta[z1, a, b] - Beta[z0, a, b]."
BetaRegularized::usage = "BetaRegularized[z, a, b] gives the regularized incomplete beta function I(z, a, b) = Beta[z, a, b]/Beta[a, b]. BetaRegularized[z0, z1, a, b] gives the generalized incomplete beta function I(z1, a, b) - I(z0, a, b)."
Binomial::usage = "Binomial[n, m] gives the binomial coefficient."
Blank::usage = "_ or Blank[ ] is a pattern object that can stand for any Mathematica expression. _h or Blank[h] can stand for any expression with head h."
BlankForm::usage = "BlankForm is an internal symbol used for formatting and printing."
BlankNullSequence::usage = "___ (three _ characters) or BlankNullSequence[ ] is a pattern object that can stand for any sequence of zero or more Mathematica expressions. ___h or BlankNullSequence[h] can stand for any sequence of expressions, all of which have head h."
BlankSequence::usage = "__ (two _ characters) or BlankSequence[ ] is a pattern object that can stand for any sequence of one or more Mathematica expressions. __h or BlankSequence[h] can stand for any sequence of one or more expressions, all of which have head h."
Block::usage = "Block[{x, y, ...}, expr] specifies that expr is to be evaluated with local values for the symbols x, y, .... Block[{x = x0, ...}, expr] defines initial local values for x, .... Block[{vars}, body /; cond] allows local variables to be shared between conditions and function bodies."
Bottom::usage = "Bottom is a setting for the TableAlignments option of TableForm."
Boxed::usage = "Boxed is an option for Graphics3D. Boxed -> True draws the edges of the bounding box in a three-dimensional picture. With Boxed -> False, no bounding box is drawn."
BoxRatios::usage = "BoxRatios is an option for Graphics3D and SurfaceGraphics. BoxRatios -> {rx, ry, rz} gives the ratios of side lengths for the bounding box of the three-dimensional picture. BoxRatios -> Automatic determines the ratios using the range of actual coordinate values in the plot."
BoxStyle::usage = "BoxStyle is an option for three-dimensional graphics functions which specifies how the bounding box should be rendered. BoxStyle can be set to a list of graphics directives such as Dashing, Thickness, GrayLevel and RGBColor. BoxStyle -> Automatic uses a default style."
Break::usage = "Break[ ] exits the nearest enclosing Do, For or While."
Byte::usage = "Byte represents a single byte of data in Read."
ByteCount::usage = "ByteCount[expr] gives the number of bytes used internally by Mathematica to store expr."
C::usage = "C[i] is the default form for the i-th constant of integration produced in solving a differential equation with DSolve."
CallProcess::usage = "CallProcess[\"command\", f, {x1, x2, ...}] calls the function f in an external process, with arguments xi. (CallProcess has been superseded by MathLink operations.)"
Cancel::usage = "Cancel[expr] cancels out common factors in the numerator and denominator of expr."
Cases::usage = "Cases[{e1, e2, ...}, pattern] gives a list of the ei that match the pattern. Cases[{e1, ...}, pattern -> rhs] or Cases[{e1, ...}, pattern :> rhs] gives a list of the values of rhs corresponding to the ei that match the pattern. Cases[expr, pattern, levelspec] gives a list of all parts of expr on levels specified by levelspec which match the pattern."
Catalan::usage = "Catalan is Catalan's constant, with numerical value 0.915966...."
Catch::usage = "Catch[expr] returns the argument of the first Throw generated in the evaluation of expr."
Ceiling::usage = "Ceiling[x] gives the smallest integer greater than or equal to x."
CellArray::usage = "CellArray[{{a11, a12, ...}, ...}] is a two-dimensional graphics primitive which represents a rectangular array of gray cells."
Center::usage = "Center is used to specify alignment in printforms such as ColumnForm and TableForm."
CForm::usage = "CForm[expr] prints as a C language version of expr."
Character::usage = "Character represents a single character in Read."
Characters::usage = "Characters[\"string\"] gives a list of the characters in a string."
ChebyshevT::usage = "ChebyshevT[n, x] gives the nth Chebyshev polynomial of the first kind."
ChebyshevU::usage = "ChebyshevU[n, x] gives the nth Chebyshev polynomial of the second kind."
Check::usage = "Check[expr, failexpr] evaluates expr, and returns the result, unless messages were generated, in which case it evaluates and returns failexpr. Check[expr, failexpr, s1::t1, s2::t2, ...] checks only for the specified messages."
CheckAbort::usage = "CheckAbort[expr, failexpr] evaluates expr, returning failexpr if an abort occurs."
Chop::usage = "Chop[expr] replaces approximate real numbers in expr that are close to zero by the exact integer 0. Chop[expr, tol] replaces approximate real numbers in expr that differ from zero by less than tol with 0."
Circle::usage = "Circle[{x, y}, r] is a two-dimensional graphics primitive that represents a circle of radius r centered at the point {x, y}. Circle[{x, y}, {rx, ry}] yields an ellipse with semi-axes rx and ry. Circle[{x, y}, r, {theta1, theta2}] represents a circular arc."
Clear::usage = "Clear[symbol1, symbol2, ...] clears values and definitions for the specified symbols. Clear[\"pattern1\", \"pattern2\", ...] clears values and definitions for all symbols whose names match any of the specified string patterns."
ClearAll::usage = "ClearAll[symbol1, symbol2, ...] clears all values, definitions, attributes, messages and defaults associated with symbols. ClearAll[\"pattern1\", \"pattern2\", ...] clears all symbols whose names textually match any of the specified string patterns."
ClearAttributes::usage = "ClearAttributes[s, attr] removes attr from the list of attributes of the symbol s."
ClebschGordan::usage = "ClebschGordan[{j1,m1},{j2,m2},{j3,m3}] evaluates the Clebsch-Gordan coefficient through its relation to the 3-j symbol. The ji must satisfy triangularity conditions and m1+m2 = m3."
ClipFill::usage = "ClipFill is an option for SurfaceGraphics. With ClipFill -> Automatic, places where the surface extends beyond the bounding box are shown like the rest of the surface. ClipFill -> None shows holes in the surface where it would be clipped. ClipFill -> color shows clipped areas with a particular color. ClipFill -> {bottom, top} uses different specifications for bottom and top clipped areas."
Close::usage = "Close[stream] closes a stream."
CMYKColor::usage = "CMYKColor[cyan, magenta, yellow, black] is a graphics directive which specifies that graphical objects which follow are to be displayed in the color given."
Coefficient::usage = "Coefficient[expr, form] gives the coefficient of form in the polynomial expr. Coefficient[expr, form, n] gives the coefficient of form^n in expr."
CoefficientList::usage = "CoefficientList[poly, var] gives a list of coefficients of powers of var in poly, starting with power 0. CoefficientList[poly, {var1, var2, ...}] gives a matrix of coefficients of the vari."
CofactorExpansion::usage = "CofactorExpansion is a possible value for the Method option in Inverse, LinearSolve, NullSpace, and RowReduce. Method -> CofactorExpansion will cause RowReduce and related functions to attempt to invert the leftmost n x n submatrix of a given matrix of n rows (if it has at least n columns), and to multiply by that inverse if it is exists. This will put the original matrix into reduced row-echelon form."
Collect::usage = "Collect[expr, x] collects together terms involving the same power of x. Collect[expr, {x1, x2, ...}] collects together terms that involve the same powers of x1, x2, ...."
ColonForm::usage = "ColonForm[a,b] prints as a: b."
ColorFunction::usage = "ColorFunction is an option for various graphics functions which specifies a function to apply to z values to determine the color to use for a particular x, y region. The arguments provided for the specified function are always in the range 0 to 1. The specified function must return a CMYKColor, GrayLevel, Hue or RGBColor directive. ColorFunction -> Automatic yields a range of gray levels. ColorFunction -> Hue yields a range of colors."
ColorOutput::usage = "ColorOutput is an option for graphics functions which specifies the type of color output to produce. ColorOutput -> Automatic uses whatever color directives are given. ColorOutput -> CMYKColor converts to CMYKColor. ColorOutput -> GrayLevel converts to GrayLevel. ColorOutput -> RGBColor converts to RGBColor. ColorOutput -> f converts using the function f."
Column::usage = "Column is a setting for the TableDirections option of TableForm."
ColumnForm::usage = "ColumnForm[{e1, e2, ...}] prints as a column with e1 above e2, etc. ColumnForm[list, horiz] specifies the horizontal alignment of each element. ColumnForm[list, horiz, vert] also specifies the vertical alignment of the whole column."
$CommandLine::usage = "$CommandLine is a list of strings giving the elements of the original operating system command line with which Mathematica was invoked."
Compile::usage = "Compile[{x1, x2, ...}, expr] creates a compiled function which evaluates expr assuming numerical values of the xi. Compile[{{x1, t1}, ...}, expr] assumes that xi is of a type which matches ti. Compile[vars, expr, {{p1, pt1}, ...}] assumes that subexpressions in expr which match pi are of types which match pti."
Compiled::usage = "Compiled is an option for various numerical and plotting functions. With Compiled -> True, expressions they work with are automatically compiled. With Compiled -> False, they are not."
CompiledFunction::usage = "Compiled is an option for various numerical and plotting functions. With Compiled -> True, expressions they work with are automatically compiled. With Compiled -> False, they are not."
Complement::usage = "Complement[eall, e1, e2, ...] gives the elements in eall which are not in any of the ei."
Complex::usage = "Complex is the head used for complex numbers."
ComplexExpand::usage = "ComplexExpand[expr] expands expr assuming that all variables are real. ComplexExpand[expr, {x1, x2, ...}] expands expr assuming that variables matching any of the xi are complex."
ComplexInfinity::usage = "ComplexInfinity represents a quantity with infinite magnitude, but undetermined complex phase."
Compose::usage = "Compose is an obsolete function, superseded by Composition.\n Compose[a,b,c,d] gives a[b[c[d]]]."
ComposeList::usage = "ComposeList[{f1, f2, ...}, x] generates a list of the form {x, f1[x], f2[f1[x]], ...}."
ComposeSeries::usage = "ComposeSeries[s,t,u,...] composes the power series s,t,u, etc. The series (except for the first element) must begin with a positive power of the variable."
Composition::usage = "Composition[f1, f2, f3, ...] represents a composition of the functions f1, f2, f3, ...."
CompoundExpression::usage = "expr1; expr2; ... evaluates the expri in turn, giving the last one as the result."
Condition::usage = "patt /; test is a pattern which matches only if the evaluation of test yields True. lhs :> rhs /; test represents a rule which applies only if the evaluation of test yields True. lhs := rhs /; test is a definition to be used only if test yields True."
$ConditionHold::usage = "$ConditionHold is an internal symbol."
Conjugate::usage = "Conjugate[z] gives the complex conjugate of the complex number z."
Constant::usage = "Constant is an attribute which indicates zero derivative of a symbol with respect to all parameters."
Constants::usage = "Constants is an option for Dt which gives a list of objects to be taken as constants."
ConstrainedMax::usage = "ConstrainedMax[f, {inequalities}, {x, y, ...}] finds the global maximum of f in the domain specified by the inequalities. The variables x, y, ... are all assumed to be non-negative."
ConstrainedMin::usage = "ConstrainedMin[f, {inequalities}, {x, y, ...}] finds the global minimum of f in the domain specified by the inequalities. The variables x, y, ... are all assumed to be non-negative."
$Context::usage = "$Context is a global variable that gives the current context."
Context::usage = "Context[ ] gives the current context. Context[symbol] gives the context in which a symbol appears."
$ContextPath::usage = "$ContextPath is a global variable that gives a list of contexts, after $Context, to search in trying to find a symbol that has been entered."
Contexts::usage = "Contexts[ ] gives a list of all contexts. Contexts[\"string\"] gives a list of the contexts which match the string. The string can contain metacharacters. See also: $Packages, $ContextPath."
ContextToFilename::usage = "ContextToFilename[\"context`\"] gives the string specifying the file name that is by convention associated with a particular context."
Continuation::usage = "Continuation[n] is output at the beginning of the nth line in a multiline printed expression."
Continue::usage = "Continue[ ] exits to the nearest enclosing Do, For or While in a procedural program."
ContourGraphics::usage = "ContourGraphics[array] is a representation of a contour plot."
ContourLevels::usage = "ContourLevels is an obsolete graphics option, superseded by Contours."
ContourLines::usage = "ContourLines is an option for contour plots. With Contourlines -> True, explicit contour lines are drawn. With Contourlines -> False, no contour lines are drawn."
ContourPlot::usage = "ContourPlot[f, {x, xmin, xmax}, {y, ymin, ymax}] generates a contour plot of f as a function of x and y."
Contours::usage = "Contours is an option for ContourGraphics specifying the contours to use. Contours -> n chooses n equally spaced contours between the minimum and maximum z values. Contours -> {z1, z2, ... } specifies the explicit z values to use for contours."
ContourShading::usage = "ContourShading is an option for contour plots. With ContourShading -> False, regions between contour lines are left blank. With ContourShading -> True, regions are colored based on the setting for the option ColorFunction."
ContourSmoothing::usage = "ContourSmoothing is an option for contour plots. With ContourSmoothing -> False, contour lines are computed using linear interpolation. With ContourSmoothing -> True, cubic interpolation is used."
ContourSpacing::usage = "ContourSpacing is an obsolete graphics option, superseded by Contours."
ContourStyle::usage = "ContourStyle is an option for contour plots. With ContourStyle -> style, all contour lines are generated with the specified graphics directive, or list of graphics directives. ContourStyle -> {{style1}, {style2}, ... } specifies that successive contour lines should use graphics directives style1, ... . ContourStyle -> Automatic uses a default style."
CopyDirectory::usage = "CopyDirectory[\"dir1\", \"dir2\"] copies the directory dir1 to dir2."
CopyFile::usage = "CopyFile[\"file1\", \"file2\"] copies file1 to file2."
Cos::usage = "Cos[z] gives the cosine of z."
Cosh::usage = "Cosh[z] gives the hyperbolic cosine of z."
CoshIntegral::usage = "CoshIntegral[x] gives the hyperbolic cosine integral EulerGamma + Log[x] + Integrate[(Cosh[t] - 1)/t, {t, 0, x}]."
CosIntegral::usage = "CosIntegral[x] gives the cosine integral EulerGamma + Log[x] + Integrate[(Cos[t] - 1)/t, {t, 0, x}]."
Cot::usage = "Cot[z] gives the cotangent of z."
Coth::usage = "Coth[z] gives the hyperbolic cotangent of z."
Count::usage = "Count[list, pattern] gives the number of elements in list that match pattern. Count[expr, pattern, levelspec] gives the total number of subexpressions matching pattern that appear at the levels in expr specified by levelspec."
CreateDirectory::usage = "CreateDirectory[\"dir\"] creates a directory."
$CreationDate::usage = "$CreationDate gives the date and time at which the particular release of the Mathematica kernel you are running was created."
Csc::usage = "Csc[z] gives the cosecant of z."
Csch::usage = "Csch[z] gives the hyperbolic cosecant of z."
Cubics::usage = "Cubics is an option for Roots and related functions. With Cubics -> True, explicit solutions are generated for irreducible cubic equations. Cubics -> False causes irreducible cubics to be left unsolved in their original symbolic form."
Cuboid::usage = "Cuboid[{xmin, ymin, zmin}] is a three-dimensional graphics primitive that represents a unit cuboid, oriented parallel to the axes. Cuboid[{xmin, ymin, zmin}, {xmax, ymax, zmax}] specifies a cuboid by giving the coordinates of opposite corners."
Cyclotomic::usage = "Cyclotomic[n, x] gives the cyclotomic polynomial of order n in x."
D::usage = "D[f, x] gives the partial derivative of f with respect to x. D[f, {x, n}] gives the nth partial derivative with respect to x. D[f, x1, x2, ...] gives a mixed derivative."
DampingFactor::usage = "DampingFactor is an option for FindRoot, which can be used to control convergence behavior. Dampingfactor -> n uses a damping factor of n in Newton's method."
Dashing::usage = "Dashing[{r1, r2, ...}] is a two-dimensional graphics directive which specifies that lines which follow are to be drawn dashed, with successive segments of lengths r1, r2, ... (repeated cyclically). The ri are given as a fraction of the total width of the graph."
DataOnly::usage = "DataOnly is an option to Dump. When available, the option DataOnly -> True can be used to specify that only data and not Mathematica program text should be included in the dump file. With DataOnly -> False, both data and text are included."
Date::usage = "Date[ ] gives the current local date and time in the form {year, month, day, hour, minute, second}."
Debug::usage = "Debug is an obsolete function, superseded by Trace. Debug[expr] evaluates expr, allowing you to stop at certain points in some control structures, and see what's happening or run commands. Debug[expr, {f1, f2, ...}] stops only in evaluation of the functions fi (and everything they call)."
DeclarePackage::usage = "DeclarePackage[\"context`\", {\"name1\", \"name2\", ...}] declares that Needs[\"context`\"] should automatically be executed if a symbol with any of the specified names is ever used."
Decompose::usage = "Decompose[poly, x] decomposes a polynomial, if possible, into a composition of simpler polynomials."
Decrement::usage = "x-- decreases the value of x by 1, returning the old value of x."
Default::usage = "Default[f], if defined, gives the default value for arguments of the function f obtained with a _. pattern object. Default[f, i] gives the default value to use when _. appears as the ith argument of f. Default[f, i, n] gives the default value for the ith argument out of a total of n arguments."
DefaultColor::usage = "DefaultColor is an option for graphics functions which specifies the default color to use for lines, points, etc. The setting must be a CMYKColor, GrayLevel, Hue or RGBColor directive. The default setting DefaultColor -> Automatic gives a color complementary to the background specified."
$DefaultFont::usage = "$DefaultFont gives the default font to use for text in graphics."
DefaultFont::usage = "DefaultFont is an option for graphics functions which specifies the default font to use for text. DefaultFont -> {\"font\", size} specifies the name and size of the font to use. The default setting is DefaultFont :> $DefaultFont."
DefaultValues::usage = "DefaultValues[f] gives a list of transformation rules corresponding to all defaults (values for Default[f[x,..],..], etc.) defined for the symbol f."
Definition::usage = "Definition[s1, s2, ...] prints as the definitions given for the symbols si."
Degree::usage = "Degree gives the number of radians in one degree. It has a numerical value of Pi/180."
Delete::usage = "Delete[expr, n] deletes the element at position n in expr. If n is negative, the position is counted from the end. Delete[expr, {i, j, ...}] deletes the part at position {i, j, ...}. Delete[expr, {{i1, j1, ...}, {i2, j2, ...}, ...}] deletes parts at several positions."
DeleteCases::usage = "DeleteCases[expr, pattern] removes all elements of expr which match pattern. DeleteCases[expr, pattern, levspec] removes all parts of expr on levels specified by levspec which match pattern."
DeleteContents::usage = "DeleteContents is an option to DeleteDirectory. DeleteContents -> True deletes the directory and all files and directories it contains. DeleteContents -> False deletes the directory only if it contains no files."
DeleteDirectory::usage = "DeleteDirectory[\"dir\"] deletes the specified directory."
DeleteFile::usage = "DeleteFile[\"file\"] deletes a file. DeleteFile[{\"file1\", \"file2\", ...}] deletes a list of files."
Delimiters::usage = "Delimiters is an option to Splice that specifies the delimiters to look for. The default is Delimiters -> {\"<*\", \"*>\"}."
Denominator::usage = "Denominator[expr] gives the denominator of expr."
DensityGraphics::usage = "DensityGraphics[array] is a representation of a density plot."
DensityPlot::usage = "DensityPlot[f, {x, xmin, xmax}, {y, ymin, ymax}] makes a density plot of f as a function of x and y."
Depth::usage = "Depth[expr] gives the maximum number of indices needed to specify any part of expr, plus one."
Derivative::usage = "f' represents the derivative of a function f of one argument. Derivative[n1, n2, ...][f] is the general form, representing a function obtained from f by differentiating n1 times with respect to the first argument, n2 times with respect to the second argument, and so on."
Det::usage = "Det[m] gives the determinant of the square matrix m."
DiagonalMatrix::usage = "DiagonalMatrix[list] gives a matrix with the elements of list on the leading diagonal, and 0 elsewhere."
Dialog::usage = "Dialog[ ] initiates a dialog. Dialog[expr] initiates a dialog with expr as the current value of %."
DialogIndent::usage = "DialogIndent[d] is printed as the indentation for input and output lines in a depth d dialog."
DialogProlog::usage = "DialogProlog is an option for Dialog which can give an expression to evaluate before the dialog starts. You must use a delayed rule of the form DialogProlog :> expr to prevent expr from evaluating prematurely."
DialogSymbols::usage = "DialogSymbols is an option for Dialog which gives a list of symbols whose values should be localized in the dialog. DialogSymbols :> {x, y, ... } specifies that x, y, ... should have local values for the duration of the dialog. DialogSymbols :> {x = x0, y = y0, ... } defines initial values for variables."
DigitBlock::usage = "DigitBlock is an option for NumberForm and related functions which specifies the maximum length of blocks of digits between breaks. With DigitBlock -> Infinity, no breaks are inserted. DigitBlock -> n inserts a break every n digits. DigitBlock -> {nleft, nright} inserts a break every nleft digits to the left of the decimal point, and every nright digits to the right of the decimal point."
DigitQ::usage = "DigitQ[string] yields True if all the characters in the string are digits in the range 0 through 9, and yields False otherwise."
Digits::usage = "Digits is an obsolete function, superseded by IntegerDigits and RealDigits.\n Digits[n] gives a list of the digits of the integer n. Digits[n, b] gives a list of the digits in base b. Digits[x, b] gives a list containing a list of digits of the integer part of x, a list of digits of the fractional part, and the exponent of b."
Dimensions::usage = "Dimensions[expr] gives a list of the dimensions of expr. Dimensions[expr, n] gives a list of the dimensions of expr down to level n."
DirectedInfinity::usage = "DirectedInfinity[ ] represents an infinite numerical quantity whose direction in the complex plane is unknown. DirectedInfinity[z] represents an infinite numerical quantity that is a positive real multiple of the complex number z."
Direction::usage = "Direction is an option for Limit. With Direction -> 1, the limit is taken from below. With Direction -> -1, the limit is taken from above. Direction -> Automatic uses Direction -> -1 except for limits at Infinity, where it is equivalent to Direction -> 1."
Directory::usage = "Directory[ ] gives the current working directory."
DirectoryStack::usage = "DirectoryStack[ ] gives the directory stack which represents the sequence of current directories used."
Disk::usage = "Disk[{x, y}, r] is a two-dimensional graphics primitive that represents a filled disk of radius r centered at the point {x, y}. Disk[{x, y}, {rx, ry}] yields an elliptical disk with semi-axes rx and ry. Disk[{x, y}, r, {theta1, theta2}] represents a segment of a disk."
Dispatch::usage = "Dispatch[{lhs1->rhs1, lhs2->rhs2, ...}] generates an optimized dispatch table representation of a list of rules. The object produced by Dispatch can be used to give the rules in expr /. rules."
$Display::usage = "$Display gives a list of files and pipes to be used with the default $DisplayFunction."
Display::usage = "Display[channel, graphics] writes graphics or sound to the specified output channel."
$DisplayFunction::usage = "$DisplayFunction gives the default setting for the option DisplayFunction in graphics functions."
DisplayFunction::usage = "DisplayFunction is an option for graphics and sound functions that specifies the function to apply to graphics and sound primitives in order to display them. The default setting in graphics functions is $DisplayFunction, and in sound functions is $SoundDisplayFunction. A typical setting is DisplayFunction -> (Display[channel, #]&). DisplayFunction -> Identity causes the objects to be returned, but no display to be generated."
Distribute::usage = "Distribute[f[x1, x2, ...]] distributes f over Plus appearing in any of the xi. Distribute[expr, g] distributes over g. Distribute[expr, g, f] performs the distribution only if the head of expr is f."
Divide::usage = "x/y or Divide[x, y] is equivalent to x y^-1."
DivideBy::usage = "x /= c divides x by c and returns the new value of x."
DivisionFreeRowReduction::usage = "DivisionFreeRowReduction is a possible value for the Method options in Inverse, LinearSolve, NullSpace, and RowReduce. Method -> DivisionFreeRowReduction causes Gaussian elimination of symbolic matrices to initially clear denominators in each row and subsequently to not attempt to simplify pivots for row operations."
Divisors::usage = "Divisors[n] gives a list of the integers that divide n."
DivisorSigma::usage = "DivisorSigma[k, n] gives the sum of the kth powers of the positive divisors of n."
Do::usage = "Do[expr, {imax}] evaluates expr imax times. Do[expr, {i, imax}] evaluates expr with the variable i successively taking on the values 1 through imax (in steps of 1). Do[expr, {i, imin, imax}] starts with i = imin. Do[expr, {i, imin, imax, di}] uses steps di. Do[expr, {i, imin, imax}, {j, jmin, jmax}, ...] evaluates expr looping over different values of j, etc. for each i. Do[] returns Null, or the argument of the first Return it evaluates."
Dot::usage = "a.b.c or Dot[a, b, c] gives products of vectors, matrices and tensors."
DoubleExponential::usage = "DoubleExponential is a choice for the option Method of NIntegrate. Method -> DoubleExponential causes a doubly exponentially convergent algorithm to be used. For multi-dimensional integration, DoubleExponential refers to a Cartesian product of one-dimensional doubly exponentially convergent quadrature rules. "
DoublyInfinite::usage = "DoublyInfinite is an option for LerchPhi. With DoublyInfinite -> True, the summation is taken from -Infinity to Infinity. With DoublyInfinite -> False, the summation is taken from zero to Infinity."
DownValue::usage = "DownValue is an obsolete function, superseded by DownValues.\n DownValues[f] gives a list of transformation rules corresponding to all downvalues (values for f[x,..], etc.) defined for the symbol f."
DownValues::usage = "DownValues[f] gives a list of transformation rules corresponding to all downvalues defined for the symbol f."
Drop::usage = "Drop[list, n] gives list with its first n elements dropped. Drop[list, -n] gives list with its last n elements dropped. Drop[list, {n}] gives list with its nth element dropped. Drop[list, {m, n}] gives list with elements m through n dropped."
DSolve::usage = "DSolve[eqn, y[x], x] solves a differential equation for the functions y[x], with independent variable x. DSolve[{eqn1, eqn2, ...}, {y1[x1, ...], ...}, {x1, ...}] solves a list of differential equations."
DSolveConstants::usage = "DSolveConstants is an option to DSolve that determines the constants of integration which may be returned. The default is DSolveConstants -> C, which yields constants of integration c[1], c[2], ... ."
Dt::usage = "Dt[f, x] gives the total derivative of f with respect to x. Dt[f] gives the total differential of f. Dt[f, {x, n}] gives the nth total derivative with respect to x. Dt[f, x1, x2, ...] gives a mixed total derivative."
Dump::usage = "Dump[\"filename\"] writes a complete image of the current state of your Mathematica session to a file. Dump[\"filename\", startup] includes the Mathematica expression startup, to be run when the image is executed. Dump[\"filename\", startup, \"code\"] uses the executable binary in the file \"code\". The default for \"code\" is First[$CommandLine]."
$DumpDates::usage = "$DumpDates gives the list of all dates and times at which Dump was used in creating the Mathematica system you are running."
$DumpedPackages::usage = "$DumpedPackages gives a list of the packages which have been dumped into the system."
$DumpSupported::usage = "$DumpSupported is True if Dump can be used in the version of Mathematica you are running, and is False otherwise."
E::usage = "E is the exponential constant e (base of natural logarithms), with numerical value 2.71828...."
$Echo::usage = "$Echo gives a list of files and pipes to which all input is echoed."
EdgeForm::usage = "EdgeForm[g] is a three-dimensional graphics directive which specifies that edges of polygons are to be drawn using the graphics directive or list of graphics directives g."
Edit::usage = "Edit[expr___] lets you edit the expressions expr."
EditDef::usage = "EditDef is the obsolete name of EditDefinition."
EditDefinition::usage = "EditDefinition[syms___] lets you edit the rules attached to the symbols syms."
EditIn::usage = "EditIn[n__Integer] lets you edit input lines n. EditIn[] edits the previous input line."
Eigensystem::usage = "Eigensystem[m] gives a list {values, vectors} of the eigenvalues and eigenvectors of the square matrix m."
Eigenvalues::usage = "Eigenvalues[m] gives a list of the eigenvalues of the square matrix m."
Eigenvectors::usage = "Eigenvectors[m] gives a list of the eigenvectors of the square matrix m."
Eliminate::usage = "Eliminate[eqns, vars] eliminates variables between a set of simultaneous equations."
EllipticE::usage = "EllipticE[m] gives the complete elliptic integral E(m). EllipticE[phi, m] gives the elliptic integral of the second kind E(phi|m)."
EllipticExp::usage = "EllipticExp[u, {a, b}] gives the generalized exponential associated with the elliptic curve y^2 = x^3 + a x^2 + b x."
EllipticExpPrime::usage = "EllipticExpPrime[u, {a, b}] gives the derivative with respect to the first argument of EllipticExp[u, {a, b}]."
EllipticF::usage = "EllipticF[phi, m] gives the elliptic integral of the first kind F(phi|m)."
EllipticK::usage = "EllipticK[m] gives the complete elliptic integral of the first kind K(m)."
EllipticLog::usage = "EllipticLog[{x, y}, {a, b}] gives the generalized logarithm associated with the elliptic curve y^2 == x^3 + a x^2 + b x."
EllipticNomeQ::usage = "EllipticNomeQ[m] gives the nome q == Exp[-Pi EllipticK[1-m]/EllipticK[m]]."
EllipticPi::usage = "EllipticPi[n, phi, m] gives the elliptic integral of the third kind Pi(n; phi|m). EllipticPi[n, m] gives the complete elliptic integral Pi(n|m)."
EllipticTheta::usage = "EllipticTheta[i, z, q] gives the elliptic theta function theta_i(z, q), where i = 1, 2, 3, or 4."
EllipticThetaPrime::usage = "EllipticThetaPrime[i, z, q] gives the derivative with respect to the second argument of the elliptic theta function theta_i(z, q), where i = 1, 2, 3, or 4."
Encode::usage = "Encode[\"source\", \"dest\"] writes an encoded version of the file source to the file dest. <<dest decodes the file before reading its contents. Encode[\"source\", \"dest\", \"key\"] produces an encoded file which must be read in using Get[\"dest\", \"key\"]."
End::usage = "End[ ] returns the present context, and reverts to the previous one."
EndAdd::usage = "EndAdd[ ] returns the present context, and reverts to the previous one, prepending the present context to $ContextPath."
EndOfFile::usage = "EndOfFile is a symbol returned by Read when it reaches the end of a file."
EndPackage::usage = "EndPackage[ ] restores $Context and $ContextPath to their values before the preceding BeginPackage, and prepends the current context to the list $ContextPath."
EndProcess::usage = "EndProcess[\"command\"] terminates an external process in which functions could be called from Mathematica. (EndProcess has been superseded by MathLink operations.)"
EngineeringForm::usage = "EngineeringForm[expr] prints with all real numbers in expr given in engineering notation."
Environment::usage = "Environment[\"var\"] gives the value of an operating system environment variable."
$Epilog::usage = "$Epilog is a symbol whose value, if any, is evaluated when a dialog or a Mathematica session is terminated."
Epilog::usage = "Epilog is an option for graphics functions which gives a list of graphics primitives to be rendered after the main part of the graphics is rendered."
Equal::usage = "lhs == rhs returns True if lhs and rhs are identical."
EquatedTo::usage = "EquatedTo is an option for Roots, which specifies an expression to use in place of the variable in the solution."
Erf::usage = "Erf[z] gives the error function erf(z). Erf[z0, z1] gives the generalized error function erf(z1) - erf(z0)."
Erfc::usage = "Erfc[z] gives the complementary error function erfc(z) == 1 - erf(z)."
Erfi::usage = "Erfi[z] gives the imaginary error function erfi(z) == -i erf(i z)."
EulerE::usage = "EulerE[n] gives the nth Euler number. EulerE[n, x] gives the nth Euler polynomial."
EulerGamma::usage = "EulerGamma is Euler's constant gamma, with numerical value 0.577216...."
EulerPhi::usage = "EulerPhi[n] gives the Euler totient function phi(n). It is the number of positive integers less than n which are relatively prime to n."
Evaluate::usage = "Evaluate[expr] causes expr to be evaluated, even if it appears as the argument of a function whose attributes specify that it should be held unevaluated."
EvenQ::usage = "EvenQ[expr] gives True if expr is an even integer, and False otherwise."
Exit::usage = "Exit[ ] terminates a Mathematica session."
Exp::usage = "Exp[z] is the exponential function."
Expand::usage = "Expand[expr] expands out products and positive integer powers in expr. Expand[expr, patt] avoids expanding elements of expr which do not contain terms matching the pattern patt."
ExpandAll::usage = "ExpandAll[expr] expands out all products and integer powers in any part of expr. ExpandAll[expr, patt] avoids expanding parts of expr which do not contain terms matching the pattern patt."
ExpandDenominator::usage = "ExpandDenominator[expr] expands out products and powers that appear as denominators in expr."
ExpandNumerator::usage = "ExpandNumerator[expr] expands out products and powers that appear in the numerator of expr."
ExpIntegralE::usage = "ExpIntegralE[n, z] gives the exponential integral function E(n,z)."
ExpIntegralEi::usage = "ExpIntegralEi[z] gives the exponential integral function Ei(z)."
Exponent::usage = "Exponent[expr, form] gives the maximum power with which form appears in expr. Exponent[expr, form, h] applies h to the set of exponents with which form appears in expr."
ExponentFunction::usage = "ExponentFunction is an option for NumberForm and related functions. ExponentFunction -> Automatic determines the exponent to be used in printing approximate real numbers based on the output form of the number. A typical setting is ExponentFunction -> (3 Quotient[#, 3]&)."
ExponentStep::usage = "(Obsolete: see ExponentFunction) ExponentStep is an option for NumberForm and related functions, which determines the interval between possible exponents to use when printing approximate real numbers."
Expression::usage = "Expression is a symbol that represents an ordinary Mathematica expression in Read and related functions."
ExtendedGCD::usage = "ExtendedGCD[n, m] gives the extended greatest common divisor of the integers n and m."
FaceForm::usage = "FaceForm[gf, gb] is a three-dimensional graphics directive which specifies that the front faces of polygons are to be drawn with the graphics primitive gf, and the back faces with gb."
FaceGrids::usage = "FaceGrids is an option for three-dimensional graphics functions. With FaceGrids -> All, grid lines are drawn on all the faces of the bounding box. FaceGrids -> None draws no grid lines. FaceGrids -> {face1, face2, ... } draws grid lines on the specified faces. FaceGrids -> {{face1, {xgrid, ygrid}}, ... } specifies an arrangement of the grid lines."
Factor::usage = "Factor[poly] factors a polynomial over the integers. Factor[poly, Modulus->p] factors a polynomial modulo a prime p."
FactorComplete::usage = "FactorComplete is an option for FactorInteger. With FactorInteger -> True, complete factorization is performed; with FactorComplete -> False, at most one factor is extracted."
Factorial::usage = "n! gives the factorial of n."
Factorial2::usage = "n!! gives the double factorial of n."
FactorInteger::usage = "FactorInteger[n] gives a list of the prime factors of the integer n, together with their exponents."
FactorList::usage = "FactorList[poly] gives a list of the factors of a polynomial, together with their exponents. FactorList[poly, Modulus->p] factors a polynomial modulo a prime p."
FactorSquareFree::usage = "FactorSquareFree[poly] writes a polynomial as a product of square-free factors. FactorSquareFree[poly, Modulus->p] factors a polynomial modulo a prime p."
FactorSquareFreeList::usage = "FactorSquareFreeList[poly] gives a list of square-free factors of a polynomial, together with their exponents. FactorSquareFreeList[poly, Modulus->p] factors a polynomial modulo a prime p."
FactorTerms::usage = "FactorTerms[poly] pulls out any overall numerical factor in poly."
FactorTermsList::usage = "FactorTermsList[poly] pulls out any overall numerical factor in poly and returns a list of factors."
Fail::usage = "Fail is a special symbol returned by evaluation of an obsolete use of Condition."
$Failed::usage = "$Failed is a special symbol returned by certain functions when they cannot do what they were asked to do."
False::usage = "False is the symbol for the Boolean value false."
File::usage = "File is a possible value returned by FileType and related functions to indicate the type of a file."
FileByteCount::usage = "FileByteCount[\"file\"] gives the number of bytes in a file."
FileDate::usage = "FileDate[\"file\"] gives the date and time at which a file was last modified."
FileInformation::usage = "FileInformation[file] gives information about a file."
FileNames::usage = "FileNames[ ] lists all files in the current working directory. FileNames[\"form\"] lists all files in the current working directory whose names match the string pattern form. FileNames[{\"form1\", \"form2\", ...}] lists all files whose names match any of the formi. FileNames[forms, {\"dir1\", \"dir2\", ...}] lists files with names matching forms in any of the directories diri. FileNames[forms, dirs, n] includes files that are in subdirectories up to n levels down."
FileType::usage = "FileType[\"file\"] gives the type of a file, typically File, Directory or None."
Find::usage = "Find[stream, \"text\"] finds the first record in an input stream that contains the specified string. Find[stream, {\"text1\", \"text2\", ...}] finds the first record that contains any of the specified strings."
FindList::usage = "FindList[\"file\", \"text\"] gives a list of all records in the file that contain the specified string. FindList[\"file\", {\"text1\", \"text2\", ...}] gives a list of all records that contain any of the specified strings. FindList[{\"file1\", ...}, text] gives a list of records containing the specified strings in any of the files. FindList[files, text, n] includes only the first n records found."
FindMinimum::usage = "FindMinimum[f, {x, x0}] searches for a local minimum in f, starting from the point x=x0."
FindRoot::usage = "FindRoot[lhs == rhs, {x, x0}] searches for a numerical solution to the equation lhs == rhs, starting with x == x0."
First::usage = "First[expr] gives the first element in expr."
Fit::usage = "Fit[data, funs, vars] finds a least-squares fit to a list of data as a linear combination of the functions funs of variables vars. The data can have the form {{x1, y1, ..., f1}, {x2, y2, ..., f2}, ...}, where the number of coordinates x, y, ... is equal to the number of variables in the list vars. The data can also be of the form {f1, f2, ...}, with a single coordinate assumed to take values 1, 2, .... The argument funs can be any list of functions that depend only on the objects vars."
FixedPoint::usage = "FixedPoint[f, expr] starts with expr, then applies f repeatedly until the result no longer changes. FixedPoint[f, expr, n] stops after at most n steps."
FixedPointList::usage = "FixedPointList[f, expr] generates a list giving the results of applying f repeatedly, starting with expr, until the results no longer change. FixedPointList[f, expr, n] stops after at most n steps."
Flat::usage = "Flat is an attribute that can be assigned to a symbol f to indicate that all expressions involving nested functions f should be flattened out. This property is accounted for in pattern matching."
Flatten::usage = "Flatten[list] flattens out nested lists. Flatten[list, n] flattens to level n. Flatten[list, n, h] flattens subexpressions with head h."
FlattenAt::usage = "FlattenAt[list, n] flattens out a sublist that appears as the nth element of list. If n is negative, the position is counted from the end. FlattenAt[expr, {i, j, ...}] flattens out the part of expr at position {i, j, ...}. FlattenAt[expr, {{i1, j1, ...}, {i2, j2, ...}, ...}] flattens out parts of expr at several positions."
Floor::usage = "Floor[x] gives the greatest integer less than or equal to x."
Fold::usage = "Fold[f, x, list] gives the last element of FoldList[f, x, list]."
Font::usage = "Font is an internal symbol used for formatting and printing."
FontForm::usage = "FontForm[expr, {\"font\", size}] specifies that expr should be printed in the specified font and size."
For::usage = "For[start, test, incr, body] executes start, then repeatedly evaluates body and incr until test fails to give True."
Format::usage = "Format[expr] prints as the formatted form of expr. Assigning values to Format[expr] defines print forms for expressions. Format[expr, type] gives a format of the specified type."
FormatType::usage = "FormatType is an option for output streams which specifies the default format type used when printing expressions. The setting can be any standard format type: CForm, FortranForm, InputForm, OutputForm, TeXForm, and TextForm."
FormatValues::usage = "FormatValues[f] gives a list of transformation rules corresponding to all printing formats (values for Format[f[x,..],..], etc.) defined for the symbol f."
FortranForm::usage = "FortranForm[expr] prints as a Fortran language version of expr."
Fourier::usage = "Fourier[list] finds the discrete Fourier transform of a list of complex numbers."
Frame::usage = "Frame is an option for two-dimensional graphics functions. With Frame -> True, a frame is drawn around the plot. With Frame -> False, no frame is drawn. Frame -> {True, False, True, False} draws just the top and bottom of the frame."
Framed::usage = "Framed is an obsolete graphics option, superseded by Frame."
FrameLabel::usage = "FrameLabel is an option for two-dimensional graphics functions that specifies labels to be placed on the edges of a frame around a plot. FrameLabel -> {xmlabel, ymlabel} specifies labels for the bottom and left-hand edges of the frame. FrameLabel -> {xmlabel, ymlabel, xplabel, yplabel} specifies labels for each of the edges of the frame. With FrameLabel -> None, no labels are given."
FrameStyle::usage = "FrameStyle is an option for two-dimensional graphics functions. With FrameStyle -> Automatic, the edges of a frame are rendered using a default style. With FrameStyle -> style, the specified graphics directive, or list of graphics directives is used. FrameStyle -> {{xmstyle}, {ymstyle}, ... } specifies different styles for different edges of the frame."
FrameTicks::usage = "FrameTicks is an option for two-dimensional graphics functions. With FrameTicks -> Automatic, tick marks for the edges of a frame are chosen automatically. With FrameTicks -> None, no tick marks are drawn. FrameTicks -> {xmticks, ymticks, ... } specifies tick mark options separately for each edge."
FreeQ::usage = "FreeQ[expr, form] yields True if no subexpression in expr matches form, and yields False otherwise. FreeQ[expr, form, levelspec] tests only those parts of expr on levels specified by levelspec."
FresnelC::usage = "FresnelC[x] gives the Fresnel integral C[x] = Integrate[Cos[Pi t^2/2], {t, 0, x}]."
FresnelS::usage = "FresnelS[x] gives the Fresnel integral S[x] = Integrate[Sin[Pi t^2/2], {t, 0, x}]."
FromASCII::usage = "FromASCII is an obsolete function, superseded by FromCharacterCode.\n FromASCII[\"c\"] gives the ASCII integer code corresponding to the character c."
FromCharacterCode::usage = "FromCharacterCode[n] gives a string consisting of the character with integer code n. FromCharacterCode[{n1, n2, ...}] gives a string consisting of the sequence of characters with codes ni."
FromDate::usage = "FromDate[date] converts a date of the form {y, m, d, h, m, s} to an absolute number of seconds since the beginning of January 1, 1900."
FullAxes::usage = "FullAxes[graphics] returns the axes options of a graphics object."
FullDefinition::usage = "FullDefinition[s1, s2, ...] prints as the definitions given for the symbols si, and all symbols on which these depend."
FullForm::usage = "FullForm[expr] prints as the full form of expr, with no special syntax."
FullGraphics::usage = "FullGraphics[g] takes a graphics object, and generates a new one in which objects specified by graphics options are given as explicit lists of graphics primitives."
FullOptions::usage = "FullOptions[expr] gives the full settings of options explicitly specified in an expression such as a graphics object. FullOptions[expr, name] gives the full setting for the option name. FullOptions[expr, {name1, name2, ...}] gives a list of the full settings for the options namei."
Function::usage = "Function[body] or body& is a pure function. The formal parameters are # (or #1), #2, etc. Function[x, body] is a pure function with a single formal parameter x. Function[{x1, x2, ...}, body] is a pure function with a list of formal parameters. Function[{x1, x2, ...}, body, {attributes}] has the given attributes during evaluation."
Gamma::usage = "Gamma[a] is the Euler gamma function Gamma(a). Gamma[a, z] is the incomplete gamma function Gamma(a, z). Gamma[a, z0, z1] is the generalized incomplete gamma function Gamma(a, z0) - Gamma(a, z1)."
GammaRegularized::usage = "GammaRegularized[a, z] is the regularized incomplete gamma function Q(a, z) = Gamma(a, z)/Gamma(a). GammaRegularized[a, z0, z1] is the generalized incomplete gamma function Q(a, z0) - Q(a, z1);"
GaussianIntegers::usage = "GaussianIntegers is an option for FactorInteger, PrimeQ, Factor and related functions. With GaussianIntegers -> True, factorization is done over the Gaussian integers when possible. With GaussianIntegers -> False, factorization is done over the integers."
GaussKronrod::usage = "GaussKronrod is a choice for the option Method of NIntegrate. Method -> GaussKronrod causes adaptive Gauss-Kronrod quadrature to be used. For multi-dimensional integration, GaussKronrod refers to a Cartesian product of one-dimensional Gauss-Kronrod quadrature rules."
GaussPoints::usage = "GaussPoints is an option for NIntegrate. With GaussPoints -> n, the Gaussian part of Gauss-Kronrod quadrature uses n points. With GaussPoints -> Automatic, an internal algorithm chooses the number of points."
GCD::usage = "GCD[n1, n2, ...] gives the greatest common divisor of the integers ni."
GegenbauerC::usage = "GegenbauerC[n, m, x] gives the nth Gegenbauer polynomial."
General::usage = "General is a symbol to which general system messages are attached."
Generic::usage = "Generic is a setting for the Mode option of Solve and related functions."
Get::usage = "<<name reads in a file, evaluating each expression in it, and returning the last one. Get[\"name\", key] gets a file that has been encoded with a certain key."
GetContext::usage = "GetContext[\"context`\"] loads the file named by ContextToFilename[\"context`\"], which gives the conventional filename for a package that defines \"context`\"."
GoldenRatio::usage = "GoldenRatio is the golden ratio (1 + Sqrt[5])/2, with numerical value 1.61803...."
Goto::usage = "Goto[tag] scans the current compound expression for Label[tag], and transfers control to that point."
Gradient::usage = "Gradient is an option for FindMinimum, which can be used to specify the gradient of the function whose minimum is being sought. With Gradient-> Automatic, the gradient is computed symbolically. A typical setting is Gradient -> {2 x, Sign[y]}."
Graphics::usage = "Graphics[primitives, options] represents a two-dimensional graphical image."
GraphicsArray::usage = "GraphicsArray[{g1, g2, ...}] represents a row of graphics objects. GraphicsArray[{{g11, g12, ...}, ...}] represents a two-dimensional array of graphics objects."
GraphicsSpacing::usage = "GraphicsSpacing is an option for GraphicsArray which specifies the spacing between elements in the array."
Graphics3D::usage = "Graphics3D[primitives, options] represents a three-dimensional graphical image."
GrayLevel::usage = "GrayLevel[level] is a graphics directive which specifies the gray-level intensity with which graphical objects that follow should be displayed."
Greater::usage = "x > y yields True if x is determined to be greater than y. x1 > x2 > x3 yields True if the xi form a strictly decreasing sequence."
GreaterEqual::usage = "x >= y yields True if x is determined to be greater than or equal to y. x1 >= x2 >= x3 yields True if the xi form a non-increasing sequence."
GridLines::usage = "GridLines is an option for two-dimensional graphics functions. With GridLines -> None, no grid lines are drawn. GridLines -> Automatic places the grid lines automatically. GridLines -> {xgrid, ygrid} specifies the position of grid lines in each direction."
GroebnerBasis::usage = "GroebnerBasis[{poly1, poly2, ...}, {x1, x2, ...}] gives a list of polynomials which form a Groebner basis for the ideal generated by the polyi."
Hash::usage = "Hash[expr] gives an integer hash code for any expression expr."
HashTable::usage = "HashTable is a part of the object which is returned by Dispatch."
Head::usage = "Head[expr] gives the head of expr."
Headers::usage = "Headers specifies whether output on this channel should be preceded by notebook headers. "
Heads::usage = "Heads is an option for functions which use level specifications. With Heads -> True, heads are treated like other elements of expressions for the purpose of levels. Heads -> False never includes heads as part of any level of an expression."
HeldPart::usage = "HeldPart[expr, pos] extracts the part or parts specified by pos, and wraps each of them in Hold."
HermiteH::usage = "HermiteH[n, x] gives the nth Hermite polynomial."
HermiteNormalForm::usage = "HermiteNormalForm gives the Hermite normal form for a matrix of integers."
HiddenSurface::usage = "HiddenSurface is an option for SurfaceGraphics. HiddenSurface -> True draws a solid surface. HiddenSurface -> False draws the mesh with transparent polygons."
Hold::usage = "Hold[expr] maintains expr in an unevaluated form."
HoldAll::usage = "HoldAll is an attribute which specifies that all arguments to a function are to be maintained in an unevaluated form."
HoldFirst::usage = "HoldFirst is an attribute which specifies that the first argument to a function is to be maintained in an unevaluated form."
HoldForm::usage = "HoldForm[expr] prints as the expression expr, with expr maintained in an unevaluated form."
HoldRest::usage = "HoldRest is an attribute which specifies that all but the first argument to a function are to be maintained in an unevaluated form."
HomeDirectory::usage = "HomeDirectory[ ] gives your \"home\" directory."
HorizontalForm::usage = "HorizontalForm is an internal symbol used for formatting and printing."
Hue::usage = "Hue[h] is a graphics directive which specifies that graphical objects which follow are to be displayed, if possible, in a color corresponding to hue h. Hue[h, s, b] specifies colors in terms of hue, saturation and brightness."
HypergeometricPFQ::usage = "HypergeometricPFQ[numlist, denlist, z] gives the generalized hypergeometric function pFq where numlist is a list of the p parameters in the numerator and denlist is a list of the q parameters in the denominator."
HypergeometricPFQRegularized::usage = "HypergeometricPFQRegularized[numlist, denlist, z] gives the regularized generalized hypergeometric function pFq where numlist is a list of the p parameters in the numerator and q is a list of the q parameters in the denominator. HypergeometricPFQRegularized[numlist, denlist, z] == HypergeometricPFQ[numlist, denlist, z]/(Times @@ (Gamma /@ denlist)) except when denlist contains a non-positive integer when it is defined by analytic continuation to remove the indeterminacy."
HypergeometricU::usage = "HypergeometricU[a, b, z] is the confluent hypergeometric function U(a, b, z)."
Hypergeometric0F1::usage = "Hypergeometric0F1[a, z] is the hypergeometric function 0F1(; a; z)."
Hypergeometric0F1Regularized::usage = "Hypergeometric0F1Regularized[a, z] is the hypergeometric function 0F1(; a; z)/Gamma(a)."
Hypergeometric1F1::usage = "Hypergeometric1F1[a, b, z] is the Kummer confluent hypergeometric function 1F1(a; b; z)."
Hypergeometric1F1Regularized::usage = "Hypergeometric1F1Regularized[a, b, z] is the Kummer confluent hypergeometric function 1F1(a; b; z)/Gamma(b)."
Hypergeometric2F1::usage = "Hypergeometric2F1[a, b, c, z] is the hypergeometric function 2F1(a, b; c; z)."
Hypergeometric2F1Regularized::usage = "Hypergeometric2F1Regularized[a, b, c, z] is the hypergeometric function 2F1(a, b; c; z)/Gamma(c)."
I::usage = "I represents the imaginary unit Sqrt[-1]."
Identity::usage = "Identity[expr] gives expr (the identity operation)."
IdentityMatrix::usage = "IdentityMatrix[n] gives the n X n identity matrix."
If::usage = "If[condition, t, f] gives t if condition evaluates to True, and f if it evaluates to False. If[condition, t, f, u] gives u if condition evaluates to neither True nor False."
IgnoreCase::usage = "IgnoreCase is an option for string manipulation and searching functions. With IgnoreCase -> True, lower- and upper-case letters are treated as equivalent. With IgnoreCase -> False, lower- and upper-case letters are treated as totally different."
$IgnoreEOF::usage = "$IgnoreEOF specifies whether Mathematica should terminate when it receives an end-of-file character as input."
Im::usage = "Im[z] gives the imaginary part of the complex number z."
Implies::usage = "Implies[p, q] represents the logical implication p => q."
In::usage = "In[n] is a global object that is assigned to have a delayed value of the nth input line."
IncludeSingularTerm::usage = "IncludeSingularTerm is an option for LerchPhi and Zeta. With IncludeSingularTerm -> True, terms of the form (k + a)^-s with k + a == 0 are included. With IncludeSingularTerm -> False, they are not."
Increment::usage = "x++ increases the value of x by 1, returning the old value of x."
Indent::usage = "Indent[d] is printed as the indentation for a depth d subexpression."
Indeterminate::usage = "Indeterminate is a symbol that represents a numerical quantity whose magnitude cannot be determined."
Inequality::usage = "Inequality represents a sequence of relational statements."
Infinity::usage = "Infinity is a symbol that represents a positive infinite quantity."
Infix::usage = "Infix[f[e1, e2, ...]] prints with f[e1, e2, ...] given in default infix form: e1 ~ f ~ e2 ~ f ~ e3 .... Infix[expr, h] prints with arguments separated by h: e1 h e2 h e3 ...."
Information::usage = "Information[symbol] prints information about a symbol."
Inner::usage = "Inner[f, list1, list2, g] is a generalization of Dot in which f plays the role of multiplication and g of addition."
$Input::usage = "$Input is a global variable whose value is the name of the stream from which input to Mathematica is currently being sought."
Input::usage = "Input[ ] interactively reads in one Mathematica expression. Input[\"prompt\"] requests input, using the specified string as a prompt."
InputForm::usage = "InputForm[expr] prints as a version of expr suitable for input to Mathematica."
InputStream::usage = "InputStream[\"name\", n] is an object that represents an input stream for functions such as Read and Find."
InputString::usage = "InputString[ ] interactively reads in a character string. InputString[\"prompt\"] requests input, using the specified string as a prompt."
Insert::usage = "Insert[list, elem, n] inserts elem at position n in list. If n is negative, the position is counted from the end. Insert[expr, elem, {i, j, ...}] inserts elem at position {i, j, ...} in expr. Insert[expr, elem, {{i1, j1, ...}, {i2, j2, ...}, ...}] inserts elem at several positions."
$Inspector::usage = "$Inspector is a global variable which gives a function to apply when the inspector is invoked from an interrupt menu."
Install::usage = "Install[\"command\"] starts an external program and installs Mathematica definitions to call functions in it."
InString::usage = "InString[n] is a global object that is assigned to be the text of the nth input line."
Integer::usage = "Integer is the head used for integers."
IntegerDigits::usage = "IntegerDigits[n] gives a list of the decimal digits in the integer n. IntegerDigits[n, b] gives a list of the base-b digits in the integer n. IntegerDigits[n, b, k] gives a list of length k containing the least significant digits of n."
IntegerQ::usage = "IntegerQ[expr] gives True if expr is an integer, and False otherwise."
Integrate::usage = "Integrate[f,x] gives the indefinite integral of f with respect to x. Integrate[f,{x,xmin,xmax}] gives the definite integral. Integrate[f,{x,xmin,xmax},{y,ymin,ymax}] gives a multiple integral."
InterpolatingFunction::usage = "InterpolatingFunction[range, table] represents an approximate function whose values are found by interpolation."
InterpolatingPolynomial::usage = "InterpolatingPolynomial[data, var] gives a polynomial in the variable var which provides an exact fit to a list of data. The data can have the forms {{x1, f1}, {x2, f2}, ...} or {f1, f2, ...}, where in the second case, the xi are taken to have values 1, 2, .... The fi can be replaced by {fi, dfi, ddfi, ...}, specifying derivatives at the points xi."
Interpolation::usage = "Interpolation[data] constructs an InterpolatingFunction object which represents an approximate function that interpolates the data. The data can have the forms {{x1, f1}, {x2, f2}, ...} or {f1, f2, ...}, where in the second case, the xi are taken to have values 1, 2, ...."
InterpolationOrder::usage = "InterpolationOrder is an option to Interpolation. InterpolationOrder -> n specifies interpolating polynomials of order n."
Interrupt::usage = "Interrupt[ ] generates an interrupt."
Intersection::usage = "Intersection[list1, list2, ...] gives a sorted list of the elements common to all the listi."
Interval::usage = "Interval[{min, max}] represents the range of values between min and max. Interval[{a,b}, {c,d}, ...] represents the union of the ranges a to b, c to d, ...."
IntervalIntersection::usage = "IntervalIntersection[int1, int2, ...] gives an interval representing the intersection of the intervals int1, int2, ...."
IntervalMemberQ::usage = "IntervalMemberQ[int, x] gives True if the number x in in the interval int, False otherwise. IntervalMemberQ[int1, int2] gives True if the interval int2 is contained within the interval int1."
IntervalUnion::usage = "IntervalUnion[int1, int2, ...] gives an interval representing the union of the intervals int1, int2, ...."
Inverse::usage = "Inverse[m] gives the inverse of a square matrix m."
InverseFourier::usage = "InverseFourier[list] finds the discrete inverse Fourier transform of a list of complex numbers."
InverseFunction::usage = "InverseFunction[f] represents the inverse of the function f, defined so that InverseFunction[f][y] gives the value of x for which f[x] is equal to y. For a function with several arguments, InverseFunction[f] represents the inverse with respect to the first argument. InverseFunction[f, n] represents the inverse with respect to the nth argument. InverseFunction[f, n, tot] represents the inverse with respect to the nth argument when there are tot arguments in all."
InverseFunctions::usage = "InverseFunctions is an option to Solve and related functions. With InverseFunctions -> True, inverse functions are used if necessary. With InverseFunctions -> False, they are never used. InverseFunctions -> Automatic uses inverse functions if necessary and prints a warning message."
InverseJacobiCD::usage = "InverseJacobiCD[v, m] gives the inverse of the Jacobi elliptic function cd at v for the parameter m. The result will be in the parallelogram with sides 2K and 2I K' centered at K."
InverseJacobiCN::usage = "InverseJacobiCN[v, m] gives the inverse of the Jacobi elliptic function cn at v for the parameter m. The result will be in the parallelogram with sides 2K and 2I K' centered at K."
InverseJacobiCS::usage = "InverseJacobiCS[v, m] gives the inverse of the Jacobi elliptic function cs at v for the parameter m. The result will be in the parallelogram with sides 2K and 2I K' centered at K."
InverseJacobiDC::usage = "InverseJacobiDC[v, m] gives the inverse of the Jacobi elliptic function dc at v for the parameter m. The result will be in the parallelogram with sides 2K and 2I K' centered at K + I K'."
InverseJacobiDN::usage = "InverseJacobiDN[v, m] gives the inverse of the Jacobi elliptic function dn at v for the parameter m. The result will be in the parallelogram with sides 2K and 2I K' centered at K + I K'."
InverseJacobiDS::usage = "InverseJacobiDS[v, m] gives the inverse of the Jacobi elliptic function ds at v for the parameter m. The result will be in the parallelogram with sides 2K and 2I K' centered at K + I K'."
InverseJacobiNC::usage = "InverseJacobiNC[v, m] gives the inverse of the Jacobi elliptic function nc at v for the parameter m. The result will be in the parallelogram with sides 2K and 2I K' centered at I K'."
InverseJacobiND::usage = "InverseJacobiND[v, m] gives the inverse of the Jacobi elliptic function nd at v for the parameter m. The result will be in the parallelogram with sides 2K and 2I K' centered at I K'."
InverseJacobiNS::usage = "InverseJacobiNS[v, m] gives the inverse of the Jacobi elliptic function ns at v for the parameter m. The result will be in the parallelogram with sides 2K and 2I K' centered at I K'."
InverseJacobiSC::usage = "InverseJacobiSC[v, m] gives the inverse of the Jacobi elliptic function sc at v for the parameter m. The result will be in the parallelogram with sides 2K and 2I K' centered at 0."
InverseJacobiSD::usage = "InverseJacobiSD[v, m] gives the inverse of the Jacobi elliptic function sd at v for the parameter m. The result will be in the parallelogram with sides 2K and 2I K' centered at 0."
InverseJacobiSN::usage = "InverseJacobiSN[v, m] gives the inverse of the Jacobi elliptic function sn at v for the parameter m. The result will be in the parallelogram with sides 2K and 2I K' centered at 0."
InverseSeries::usage = "InverseSeries[s] takes the series s generated by Series, and gives a series for the inverse of the function represented by s. InverseSeries[s, y] gives the inverse series in terms of the variable y."
InverseWeierstrassP::usage = "InverseWeierstrassP[{P, P'}, g2, g3] gives the value of u such that P = WeierstrassP[u, g2, g3] and P' = WeierstrassPPrime[u, g2, g3]. Note that P and P' are not independent. No attempt is made to ensure that the result is in any particular period parallelogram."
$IterationLimit::usage = "$IterationLimit gives the maximum length of evaluation chain used in trying to evaluate any expression."
JacobiAmplitude::usage = "JacobiAmplitude[u, m] gives the amplitude for Jacobi elliptic functions."
Jacobian::usage = "Jacobian is an option for FindRoot. Jacobian -> Automatic attempts symbolic computation of the Jacobian of the system of functions whose root is being sought. A typical setting is Jacobian -> {{2 x, Sign[y]}, {y, x}}."
JacobiCD::usage = "JacobiCD[u, m] gives the Jacobi elliptic function cd at u for the parameter m."
JacobiCN::usage = "JacobiCN[u, m] gives the Jacobi elliptic function cn at u for the parameter m."
JacobiCS::usage = "JacobiCS[u, m] gives the Jacobi elliptic function cs at u for the parameter m."
JacobiDC::usage = "JacobiDC[u, m] gives the Jacobi elliptic function dc at u for the parameter m."
JacobiDN::usage = "JacobiDN[u, m] gives the Jacobi elliptic function dn at u for the parameter m."
JacobiDS::usage = "JacobiDS[u, m] gives the Jacobi elliptic function ds at u for the parameter m."
JacobiNC::usage = "JacobiNC[u, m] gives the Jacobi elliptic function nc at u for the parameter m."
JacobiND::usage = "JacobiND[u, m] gives the Jacobi elliptic function nd at u for the parameter m."
JacobiNS::usage = "JacobiNS[u, m] gives the Jacobi elliptic function ns at u for the parameter m."
JacobiP::usage = "JacobiP[n, a, b, x] gives the nth Jacobi polynomial."
JacobiSC::usage = "JacobiSC[u, m] gives the Jacobi elliptic function sc at u for the parameter m."
JacobiSD::usage = "JacobiSD[u, m] gives the Jacobi elliptic function sd at u for the parameter m."
JacobiSN::usage = "JacobiSN[u, m] gives the Jacobi elliptic function sn at u for the parameter m."
JacobiSymbol::usage = "JacobiSymbol[n, m] gives the Jacobi symbol of n and m."
JacobiZeta::usage = "JacobiZeta[phi, m] gives Jacobi's Zeta function Z(phi|m)."
Join::usage = "Join[list1, list2, ...] concatenates lists together. Join can be used on any set of expressions that have the same head."
JordanDecomposition::usage = "JordanDecomposition[A] returns { S, J }, where A = S . J . Inverse[S] and J is the Jordan canonical form of A. All entries of A must have infinite precision."
Label::usage = "Label[tag] represents a point in a compound expression to which control can be transferred using Goto."
LaguerreL::usage = "LaguerreL[n, x] gives the nth Laguerre polynomial. LaguerreL[n, a, x] gives the nth generalized Laguerre polynomial."
$Language::usage = "$Language is a list of strings which give the names of languages to use for messages."
Last::usage = "Last[expr] gives the last element in expr."
LatticeReduce::usage = "LatticeReduce[{v1, v2, ...}] gives a reduced basis for the set of integer vectors vi."
LCM::usage = "LCM[n1, n2, ...] gives the least common multiple of the integers ni."
LeafCount::usage = "LeafCount[expr] gives the total number of indivisible subexpressions in expr."
Left::usage = "Left is used to specify alignment in printforms such as ColumnForm and TableForm."
LegendreP::usage = "LegendreP[n, x] gives the nth Legendre polynomial. LegendreP[n, m, x] gives the associated Legendre polynomial."
LegendreQ::usage = "LegendreQ[n, z] gives the nth Legendre function of the second kind. LegendreQ[n, m, z] gives the associated Legendre function of the second kind. "
LegendreType::usage = "LegendreType is an option for LegendreP and LegendreQ which specifies choices of branch cuts for Legendre functions in the complex plane. With LegendreType -> Complex, there is a branch cut from -Infinity to +1. With LegendreType -> Real, there are branch cuts from -Infinity to -1 and from +1 to +Infinity."
Length::usage = "Length[expr] gives the number of elements in expr."
Less::usage = "x < y yields True if x is determined to be less than y. x1 < x2 < x3 yields True if the xi form a strictly increasing sequence."
LessEqual::usage = "x <= y yields True if x is determined to be less than or equal to y. x1 <= x2 <= x3 yields True if the xi form a non-decreasing sequence."
LetterQ::usage = "LetterQ[string] yields True if all the characters in the string are letters, and yields False otherwise."
$Letters::usage = "$Letters is a list containing characters which are to be treated as letters. The lower- and upper-case forms of a particular letter can be given in a sublist."
Level::usage = "Level[expr, levelspec] gives a list of all subexpressions of expr on levels specified by levelspec. Level[expr, levelspec, f] applies f to the list of subexpressions."
Lighting::usage = "Lighting is an option to Graphics3D and related functions. With Lighting -> True, simulated illumination is used; with Lighting -> False, it is not."
LightSources::usage = "LightSources is an option to Graphics3D and related functions that specifies the properties of point light sources for simulated illumination. The basic form is LightSources -> {{direction1, color1}, {direction2, color2}, ... }. The direction is specified as {x, y, z}. The color can be specified by GrayLevel, Hue or RGBColor."
Limit::usage = "Limit[expr, x->x0] finds the limiting value of expr when x approaches x0."
$Line::usage = "$Line is a global variable that specifies the number of the current input line."
Line::usage = "Line[{pt1, pt2, ...}] is a graphics primitive which represents a line joining a sequence of points."
LinearProgramming::usage = "LinearProgramming[c, m, b] finds the vector x which minimizes the quantity c.x subject to the constraints m.x >= b and x >= 0."
LinearSolve::usage = "LinearSolve[m, b] gives the vector x which solves the matrix equation m.x==b."
LineBreak::usage = "LineBreak[n] is output between the nth and (n+1)th lines in a multiline printed expression."
LineForm::usage = "LineForm[g] is a three-dimensional graphics directive that specifies that lines are to be drawn with the graphics directive g or the list of graphics directives g."
LinkClose::usage = "LinkClose[link] closes a previously opened MathLink connection."
LinkConnect::usage = "LinkConnect[link] connects an unconnected link."
LinkConnectedQ::usage = "LinkConnectedQ[link] checks if link is connected to another process."
$Linked::usage = "$Linked is True if the Mathematica kernel is being run through MathLink."
LinkError::usage = "LinkError[link] returns error information for link in the form { errorNumber, errorExplanation }."
LinkFlush::usage = "LinkFlush[link] transmits immediately any locally buffered outgoing expressions."
LinkInterrupt::usage = "LinkInterrupt[link] sends an interrupt message to an external program over MathLink."
LinkObject::usage = "LinkObject represents a link to an external process started using LinkOpen."
LinkOpen::usage = "LinkOpen[\"command\"] returns a MathLink connection to the external program command."
LinkPatterns::usage = "LinkPatterns[link] gives the list of patterns defined in the external package which is accessed via the specified link."
LinkRead::usage = "LinkRead[link] reads an expression via MathLink from link."
LinkReadHeld::usage = "LinkReadHeld[link] reads an expression via MathLink from link and returns it wrapped in Hold."
LinkReadyQ::usage = "LinkReadyQ[link] returns True if the link has incoming data ready to be read by LinkRead."
Links::usage = "Links[] returns a list of all active MathLinks."
$LinkSupported::usage = "$LinkSupported is True if MathLink can be used in the version of Mathematica you are running, and is False otherwise."
LinkWrite::usage = "LinkWrite[link, expr, (flush:True)] writes expr via MathLink to link (synchronizing unless flush is False)."
LinkWriteHeld::usage = "LinkWriteHeld[link, Hold[expr], (flush:True)] writes expr (without the Hold) via MathLink to link (synchronizing unless flush is False)."
List::usage = "{e1, e2, ...} is a list of elements."
Listable::usage = "Listable is an attribute that can be assigned to a symbol f to indicate that the function f should automatically be threaded over lists that appear as its arguments."
ListContourPlot::usage = "ListContourPlot[array] generates a contour plot from an array of height values."
ListDensityPlot::usage = "ListDensityPlot[array] generates a density plot from an array of height values."
ListPlay::usage = "ListPlay[{a1, a2, ...}] plays a sound whose amplitude is given by the sequence of levels ai."
ListPlot::usage = "ListPlot[{y1, y2, ...}] plots a list of values. The x coordinates for each point are taken to be 1, 2, .... ListPlot[{{x1, y1}, {x2, y2}, ...}] plots a list of values with specified x and y coordinates."
ListPlot3D::usage = "ListPlot3D[array] generates a three-dimensional plot of a surface representing an array of height values. ListPlot3D[array, shades] generates a plot with each element of the surface shaded according to the specification in shades."
ListQ::usage = "ListQ[expr] gives True if expr is a list, and False otherwise."
Literal::usage = "Literal[expr] is equivalent to expr for pattern matching, but maintains expr in an unevaluated form."
Locked::usage = "Locked is an attribute which, once assigned, prevents modification of any attributes of a symbol."
Log::usage = "Log[z] gives the natural logarithm of z (logarithm to base E). Log[b, z] gives the logarithm to base b."
LogGamma::usage = "LogGamma[z] is the logarithm of the Euler gamma function Gamma(z). LogGamma[z] is different from Log[Gamma[z]] in that it has a single branch cut along the negative real axis."
LogicalExpand::usage = "LogicalExpand[expr] expands out expressions containing logical connectives such as && and ||."
LogIntegral::usage = "LogIntegral[z] is the logarithmic integral function li(z)."
LowerCaseQ::usage = "LowerCaseQ[string] yields True if all the characters in the string are lower-case letters, and yields False otherwise."
LUBackSubstitution::usage = "LUBackSubstitution[factor, b] yields the solution to the linear system A . x == b, where factor is the output of LUDecomposition[A]."
LUDecomposition::usage = "LUDecomposition[m] yields the LU decomposition for a square numerical matrix m. The result is a matrix and a permutation vector to be interpreted by LUBackSubstitution[]."
$MachineEpsilon::usage = "$MachineEpsilon gives the smallest machine-precision number which can be added to 1.0 to give a result not equal to 1.0."
$MachineID::usage = "$MachineID is a string that gives, if possible, a unique identification code for the computer being used."
MachineID::usage = "MachineID is an option to Encode which specifies the required value of $MachineID on the computer that reads the encoded file. If no value is specified, any value of $MachineID is allowed on the file-reading computer. A setting for MachineID must be a string."
$MachineName::usage = "$MachineName is a string that gives the assigned name of the computer being used, if such a name is defined."
MachineName::usage = "MachineName is an option to Encode which specifies the required value of $MachineName on the computer that reads the encoded file. If no value is specified, any value of $MachineName is allowed on the file-reading computer. A setting for MachineName must be a string."
MachineNumberQ::usage = "MachineNumberQ[x] returns True if x is a machine floating point number, and returns False otherwise."
$MachinePrecision::usage = "$MachinePrecision gives the number of decimal digits of precision used for machine-precision numbers."
$MachineType::usage = "$MachineType is a string giving the general type of computer on which Mathematica is being run."
MainSolve::usage = "MainSolve[eqns] is the underlying function for transforming systems of equations. Solve and Eliminate call it. The equations must be of the form lhs == rhs. They can be combined using && and ||. MainSolve returns False if no solutions to the equations exist, and True if all values of variables are solutions. MainSolve rearranges the equations using certain directives. MainSolve[eqns, vars, elim, rest] attempts to rearrange the equations eqns so as to solve for the variables vars, and eliminate the variables elim. The list rest can be included to specify the elimination order for any remaining variables."
MakeRules::usage = "MakeRules is an option to Solve and related functions. With MakeRules -> True, the result is presented as an AlgebraicRulesData object. With MakeRules -> False, the result is presented as a list of rules."
MantissaExponent::usage = "MantissaExponent[x] gives a list containing the mantissa and exponent of an approximate real number x."
Map::usage = "Map[f, expr] or f /@ expr applies f to each element on the first level in expr. Map[f, expr, levelspec] applies f to parts of expr specified by levelspec."
MapAll::usage = "MapAll[f, expr] or f //@ expr applies f to every subexpression in expr."
MapAt::usage = "MapAt[f, expr, n] applies f to the element at position n in expr. If n is negative, the position is counted from the end. MapAt[f, expr, {i, j, ...}] applies f to the part of expr at position {i, j, ...}. MapAt[f, expr, {{i1, j1, ...}, {i2, j2, ...}, ...}] applies f to parts of expr at several positions."
MapIndexed::usage = "MapIndexed[f, expr] applies f to the elements of expr, giving the part specification of each element as a second argument to f. MapIndexed[f, expr, levspec] applies f to all parts of expr on levels specified by levspec."
MapThread::usage = "MapThread[f, {{a1, a2, ...}, {b1, b2, ...}, ...}] gives {f[a1, b1, ...], f[a2, b2, ...], ...}. MapThread[f, {xa, xb, ...}, n] maps f over the nth level of the n-dimensional tensors xa, xb, ... ."
MatchBox::usage = "MatchBox is an internal symbol."
MatchLocalNameQ::usage = "MatchLocalNameQ is an internal symbol."
MatchLocalNames::usage = "MatchLocalNames is an option for Trace and related functions. With MatchLocalNames -> True, symbols such as x match symbols with local names of the form x$nnn. With MatchLocalNames -> False, they do not."
MatchQ::usage = "MatchQ[expr, form] returns True if the pattern form matches expr, and returns False otherwise."
MatrixExp::usage = "MatrixExp[mat] gives the matrix exponential of mat."
MatrixForm::usage = "MatrixForm[list] prints with the elements of list arranged in a regular array."
MatrixPower::usage = "MatrixPower[mat, n] gives the nth matrix power of mat."
MatrixQ::usage = "MatrixQ[expr] gives True if expr is a list of lists that can represent a matrix, and gives False otherwise. MatrixQ[expr, test] gives True only if test yields True when applied to each of the matrix elements in expr."
Max::usage = "Max[x1, x2, ...] yields the numerically largest of the xi. Max[{x1, x2, ...}, {y1, ...}, ...] yields the largest element of any of the lists."
MaxBend::usage = "MaxBend is an option for Plot which measures the maximum bend angle between successive line segments on a curve. MaxBend -> n specifies the maximum bend as n degrees."
MaxIterations::usage = "MaxIterations is an option for various functions that use an iterative algorithm. With MaxIterations -> n, a maximum of n iterations is used."
$MaxMachineNumber::usage = "$MaxMachineNumber is the largest machine-precision number that can be used on a particular computer system."
MaxMemoryUsed::usage = "MaxMemoryUsed[ ] gives the maximum number of bytes used to store all data for the current Mathematica session."
$MaxNumber::usage = "$MaxNumber gives the largest representable number."
$MaxPrecision::usage = "$MaxPrecision is the upper bound for the precision of inexact numbers. Even if precision is gained it will always be adjusted to be at most $MaxPrecision."
MaxRecursion::usage = "MaxRecursion is an option for various numerical functions that use a recursive algorithm. With MaxRecursion -> n, the maximum depth to which recursion is allowed to go is n even if convergence is not yet achieved."
MaxSteps::usage = "MaxSteps is an option to NDSolve. With MaxSteps -> n, the maximum number of steps taken is n."
MaxStepSize::usage = "MaxStepSize is an option to NDSolve that determines the maximum size of each step."
$$Media::usage = "$$Media is an obsolete symbol, superseded by Streams[ ]."
MemberQ::usage = "MemberQ[list, form] returns True if an element of list matches form, and False otherwise. MemberQ[list, form, levelspec] tests all parts of list specified by levelspec."
MemoryConstrained::usage = "MemoryConstrained[expr, b] evaluates expr, stopping if more than b bytes of memory are requested. MemoryConstrained[expr, b, failexpr] returns failexpr if the memory constraint is not met."
MemoryInUse::usage = "MemoryInUse[ ] gives the number of bytes currently being used to store all data in the current Mathematica session."
Mesh::usage = "Mesh is an option for SurfaceGraphics and DensityGraphics. With Mesh -> True, an explicit x-y mesh is drawn; with Mesh -> False, no mesh is drawn."
MeshRange::usage = "MeshRange is an option for ListPlot3D, SurfaceGraphics, ListContourPlot, ListDensityPlot and related functions. MeshRange -> {{xmin, xmax}, {ymin, ymax}} specifies the range of x and y coordinates that correspond to the array of z values given. MeshRange -> Automatic uses integers determined by indices in the array."
MeshStyle::usage = "MeshStyle is an option for Plot3D, DensityPlot and related functions which specifies how mesh lines should be rendered. MeshStyle can be set to a list of graphics directives including Dashing, Thickness, GrayLevel, Hue and RGBColor."
Message::usage = "Message[symbol::tag] prints the message symbol::tag unless it has been switched off. Message[symbol::tag, e1, e2, ...] prints a message, inserting the values of the ei as needed."
$MessageList::usage = "$MessageList is a global variable that gives a list of the names of messages generated during the evaluation of the current input line. Each message name is enclosed in HoldForm[ ]. $MessageList is saved in MessageList[n] and reset to { } after the nth output line is generated."
MessageList::usage = "MessageList[n] is a global object assigned to be a list of the names of messages generated during the processing of the nth input line."
MessageName::usage = "symbol::tag (or MessageName[symbol, \"tag\"]) is a name for a message."
$MessagePrePrint::usage = "$MessagePrePrint is a global variable whose value, if set, is applied to expressions before they are included in the text of messages."
$Messages::usage = "$Messages gives the list of files and pipes to which message output is sent."
Messages::usage = "Messages[symbol] gives all the messages assigned to a particular symbol."
MetaCharacters::usage = "MetaCharacters is an option to StringPosition. With MetaCharacters -> None, no strings have special meanings. MetaCharacters -> {c1, c2, c3} specifies the metacharacters for pattern escape, single character matching and multiple character matching. MetaCharacters -> Automatic is equivalent to MetaCharacters -> {\"\\\\\", \".\", \"*\"}."
Method::usage = "Method is an option to Solve, related functions, and various numerical functions, which specifies what algorithm to use in evaluating the result."
Min::usage = "Min[x1, x2, ...] yields the numerically smallest of the xi. Min[{x1, x2, ...}, {y1, ...}, ...] yields the smallest element of any of the lists."
$MinMachineNumber::usage = "$MinMachineNumber is the smallest positive machine-precision number that can be used on a particular computer system."
$MinNumber::usage = "$MinNumber gives the smallest (positive) representable number."
Minors::usage = "Minors[m, k] gives a matrix consisting of the determinants of all k X k submatrices of m."
$MinPrecision::usage = "$MinPrecision is the lower bound for the precision of inexact numbers. Even if precision is lost it will always be adjusted to be at least $MinPrecision."
MinRecursion::usage = "MinRecursion is an option for NIntegrate and other numerical functions that use a recursive algorithm. With MinRecursion -> n, a minimum depth of recursion of n is used before tests for convergence begin."
Minus::usage = "-x is the arithmetic negation of x."
Mod::usage = "Mod[m, n] gives the remainder on division of m by n. The result has the same sign as n."
Mode::usage = "Mode is an option to Solve and related functions that specifies in what sense the equations are to be solved. The possible settings for Mode are Generic, Modular, and Rational."
Modular::usage = "Modular is a setting for the option Mode in Solve and related functions, which specifies that equations need be satisfied only modulo an integer."
Module::usage = "Module[{x, y, ...}, expr] specifies that occurrences of the symbols x, y, ... in expr should be treated as local. Module[{x = x0, ...}, expr] defines initial values for x, ...."
$ModuleNumber::usage = "$ModuleNumber gives the current serial number to be used for local variables generated by Unique[ ] or Module[ ]."
Modulus::usage = "Modulus is an option that can be given to Factor and other mathematical operations. Modulus -> n specifies that numbers should be treated modulo n. Modulus -> 0 specifies that the full ring of integers should be used."
MoebiusMu::usage = "MoebiusMu[n] gives the Moebius function mu(n)."
MultiDimensional::usage = "MultiDimensional is a choice for the option Method of NIntegrate. Method -> MultiDimensional causes a multi-dimensional algorithm to be used. Method -> MultiDimensional is only valid for integration in two or more dimensions."
Multiplicity::usage = "Multiplicity is an option to Roots. Multiplicity -> n specifies that the multiplicity of each of the roots is n in the final result."
N::usage = "N[expr] gives the numerical value of expr. N[expr, n] does computations to n-digit precision."
NameQ::usage = "NameQ[\"string\"] yields True if there are any symbols whose names match the string pattern given, and yields False otherwise."
Names::usage = "Names[\"string\"] gives a list of the names of symbols which match the string. Names[\"string\", SpellingCorrection->True] includes names which match after spelling correction."
NBernoulliB::usage = "NBernoulliB[n] gives the numerical value of the nth Bernoulli number. NBernoulliB[n, d] gives the result to d-digit precision."
NDSolve::usage = "NDSolve[eqns, y, {x, xmin, xmax}] finds a numerical solution to the differential equations eqns for the function y with the independent variable x in the range xmin to xmax. NDSolve[eqns, {y1, y2, ...}, {x, xmin, xmax}] finds numerical solutions for the functions yi. NDSolve[eqns, y, {x, x1, x2, ...}] forces a function evaluation at each of x1, x2, ... The range of numerical integration is from Min[x1, x2, ...] to Max[x1, x2, ...]."
Needs::usage = "Needs[\"context`\", \"file\"] loads file if the specified context is not already in $Packages. Needs[\"context`\"] loads the file specified by ContextToFilename[\"context`\"] if the specified context is not already in $Packages."
Negative::usage = "Negative[x] gives True if x is a negative number."
Nest::usage = "Nest[f, expr, n] gives an expression with f applied n times to expr."
NestList::usage = "NestList[f, expr, n] gives a list of the results of applying f to expr 0 through n times."
$NewMessage::usage = "$NewMessage is a global variable which, if set, is applied to the symbol name and tag of messages that are requested but have not yet been defined."
$NewSymbol::usage = "$NewSymbol is a global variable which, if set, is applied to the name and context of each new symbol that Mathematica creates."
NIntegrate::usage = "NIntegrate[f, {x, xmin, xmax}] gives a numerical approximation to the integral of f with respect to x over the interval xmin to xmax."
NModule::usage = "NModule[{x, y, ...}, expr, prec] specifies that occurrences of the symbols x, y, ... in expr should be treated as local and that all local arithmetic is fixed precision and is to be done to prec digits. NModule[{x, y, ...}, expr, {minprec, maxprec}] bounds the local arithmetic to be between minprec and maxprec."
NonAssociative::usage = "NonAssociative is a symbol that represents a non-associative operator in formatting functions."
NonCommutativeMultiply::usage = "a ** b ** c is a general associative, but non-commutative, form of multiplication."
NonConstants::usage = "NonConstants is an option for D which gives a list of objects to be taken to depend implicitly on the differentiation variables."
None::usage = "None is a setting used for certain options."
NonNegative::usage = "NonNegative[x] gives True if x is a non-negative number."
Normal::usage = "Normal[expr] converts expr to a normal expression, from a variety of special forms."
Not::usage = "!expr is the logical NOT function. It gives False if expr is True, and True if it is False."
$Notebooks::usage = "$Notebooks is True if Mathematica is being used with a notebook-based front end."
NProduct::usage = "NProduct[f, {i, imin, imax}] gives a numerical approximation to the product of f with i running from imin to imax. NProduct[f, {i, imin, imax, di}] uses a step di in the product."
NProductExtraFactors::usage = "NProductExtraFactors is an option for NProduct which is used with the method SequenceLimit. NProductExtraFactors -> n uses n factors in the extrapolation process. NProductExtraFactors must be greater than twice WynnDegree."
NProductFactors::usage = "NProductFactors is an option for NProduct. NProductFactors -> n explicitly includes n factors in the product before extrapolation."
NProtectedAll::usage = "NProtectedAll is an attribute that specifies that none of the arguments to a function will be modified by the application of N[ ]."
NProtectedFirst::usage = "NProtectedFirst is an attribute that specifies that the first argument to a function will not be modified by the application of N[ ]."
NProtectedRest::usage = "NProtectedRest is an attribute that specifies that any arguments after the first argument to a function will not be modified by the application of N[ ]."
NRoots::usage = "NRoots[lhs==rhs, var] gives a list of numerical approximations to the roots of a polynomial equation."
NSolve::usage = "NSolve[eqns, vars] attempts to solve numerically an equation or set of equations for the variables vars. Any variable in eqns but not vars is regarded as a parameter. NSolve[eqns] treats all variables encountered as vars above. NSolve[eqns, vars, prec] attempts to solve numerically the equations for vars using prec digits precision."
NSum::usage = "NSum[f, {i, imin, imax}] gives a numerical approximation to the sum of f with i running from imin to imax. NSum[f, {i, imin, imax, di}] uses a step di in the sum. NSum[f, {i, imin, imax}, {j, jmin, jmax}, ...] gives a multi-dimensional summation."
NSumExtraTerms::usage = "NSumExtraTerms is an option for NSum which is used with the method SequenceLimit. NSumExtraTerms -> n uses n terms in the extrapolation process. NSumExtraTerms must be greater than twice WynnDegree."
NSumTerms::usage = "NSumTerms is an option for NSum. NSumTerms -> n explicitly includes n terms in the sum before extrapolation."
Null::usage = "Null is a symbol used to indicate the absence of an expression or a result. When it appears as an output expression, no output is printed."
NullRecords::usage = "NullRecords is an option for Read and related functions. With NullRecords -> True, null records are taken to exist between repeated record separators. With NullRecords -> False, repeated record separators are treated like single record separators."
NullSpace::usage = "NullSpace[m] gives a list of vectors that forms a basis for the null space of the matrix m."
NullWords::usage = "NullWords is an option for Read and related functions. With NullWords -> True, null words are taken to exist between repeated word separators. With NullWords -> False, repeated word separators are treated like single word separators."
Number::usage = "Number represents an exact integer or an approximate real number in Read."
$NumberBits::usage = "$NumberBits[x] gives a list containing the sign, a list of the bits thought to be correct, a list of the bits not thought to be correct, and the binary exponent. The number x must have a head of Real."
NumberForm::usage = "NumberForm[expr, n] prints with approximate real numbers in expr given to n-digit precision."
NumberFormat::usage = "NumberFormat is an option for NumberForm and related functions which specifies how the mantissa, base and exponent should be assembled into a final print form. With NumberFormat -> f, the function f is supplied with three arguments: the mantissa, base and exponent of each number to be printed. The function f must return the final format for the number. The default NumberFormat -> Automatic chooses a format automatically."
NumberPadding::usage = "NumberPadding is an option for NumberForm and related functions which gives strings to use as padding on the left- and right-hand sides of numbers. NumberPadding -> {\"sleft\", \"sright\"} specifies strings to use for padding on the left and right."
NumberPoint::usage = "NumberPoint is an option for NumberForm and related functions which gives the string to use as a decimal point. The default is NumberPoint -> \".\" ."
NumberQ::usage = "NumberQ[expr] gives True if expr is a number, and False otherwise."
NumberSeparator::usage = "NumberSeparator is an option for NumberForm and related functions which gives the string to insert at breaks between digits. With NumberSeparator -> \"s\", the string s is inserted at every break between digits specified by DigitBlock. NumberSeparator -> {\"sleft\", \"sright\"} specifies different strings to be used on the left and right of the decimal point."
NumberSigns::usage = "NumberSigns is an option for NumberForm and related functions. NumberSigns -> {\"sneg\", \"spos\"} specifies that \"sneg\" should be given as the sign for negative numbers, and \"spos\" for positive numbers. NumberSigns -> {{\"snleft\", \"snright\"}, {\"spleft\", \"spright\"}} specifies strings to put both on the left and right of numbers to specify their signs."
Numerator::usage = "Numerator[expr] gives the numerator of expr."
NValues::usage = "NValues[f] gives a list of transformation rules corresponding to all numerical values (values for N[f[x,..],..], etc.) defined for the symbol f."
O::usage = "O[x]^n represents a term of order x^n. O[x]^n is generated to represent omitted higher-order terms in power series. O[x, x0]^n represents a term of order (x - x0)^n."
OddQ::usage = "OddQ[expr] gives True if expr is an odd integer, and False otherwise."
$Off::usage = "$Off is used to mark messages that have been turned off."
Off::usage = "Off[symbol::tag] switches off a message, so that it is no longer printed. Off[s] switches off tracing messages associated with the symbol s. Off[m1, m2, ...] switches off several messages. Off[ ] switches off all tracing messages."
On::usage = "On[symbol::tag] switches on a message, so that it can be printed. On[s] switches on tracing for the symbol s. On[m1, m2, ...] switches on several messages. On[ ] switches on tracing for all symbols."
OneIdentity::usage = "OneIdentity is an attribute that can be assigned to a symbol f to indicate that f[x], f[f[x]], etc. are all equivalent to x for the purpose of pattern matching."
OneStepRowReduction::usage = "OneStepRowReduction is a possible value for the Method option in Inverse, LinearSolve, NullSpace, and RowReduce. Method -> OneStepRowReduction causes matrix entries created in the process of Gaussian elimination (row reduction) of a matrix to be divided by the previous pivot. This is always an exact (remainder-free) division. Prior to starting the reduction, denominators are cleared in each row of the matrix."
OpenAppend::usage = "OpenAppend[\"file\"] opens a file to append output to it, and returns an OutputStream object."
OpenRead::usage = "OpenRead[\"file\"] opens a file to read data from, and returns an InputStream object."
OpenTemporary::usage = "OpenTemporary[ ] opens a temporary file to which output can be written, and returns an OutputStream object."
OpenWrite::usage = "OpenWrite[\"file\"] opens a file to write output to it, and returns an OutputStream object."
Operate::usage = "Operate[p, f[x, y]] gives p[f][x, y]. Operate[p, expr, n] applies p at level n in the head of expr."
$OperatingSystem::usage = "$OperatingSystem is a string giving the type of operating system under which Mathematica is being run."
Optional::usage = "p:v is a pattern object which represents an expression of the form p, which, if omitted, should be replaced by v."
OptionQ::usage = "OptionQ[e] returns True if e can be considered an option or list of options, and False otherwise."
Options::usage = "Options[symbol] gives the list of default options assigned to a symbol. Options[expr] gives the options explicitly specified in a particular expression such as a graphics object. Options[stream] or Options[\"sname\"] gives options associated with a particular stream. Options[expr, name] gives the setting for the option name in an expression. Options[expr, {name1, name2, ...}] gives a list of the settings for the options namei."
Or::usage = "e1 || e2 || ... is the logical OR function. It evaluates its arguments in order, giving True immediately if any of them are True, and False if they are all False."
Order::usage = "Order[expr1, expr2] gives 1 if expr1 is before expr2 in canonical order, and -1 if expr1 is after expr2 in canonical order. It gives 0 if expr1 is identical to expr2."
OrderedQ::usage = "OrderedQ[h[e1, e2, ...]] gives True if the ei are in canonical order, and False otherwise."
Orderless::usage = "Orderless is an attribute that can be assigned to a symbol f to indicate that the elements ei in expressions of the form f[e1, e2, ...] should automatically be sorted into canonical order. This property is accounted for in pattern matching."
Out::usage = "%n or Out[n] is a global object that is assigned to be the value produced on the nth output line. % gives the last result generated. %% gives the result before last. %%...% (k times) gives the kth previous result."
Outer::usage = "Outer[f, list1, list2, ...] gives the generalized outer product of the listi."
$Output::usage = "$Output gives the list of files and pipes to which standard output from Mathematica is sent."
OutputForm::usage = "OutputForm[expr] prints as the standard Mathematica output form for expr."
$OutputForms::usage = "$OutputForms is a list of the formatting functions that get stripped off when wrapped around the output."
OutputStream::usage = "OutputStream[\"name\", n] is an object that represents an output stream for functions such as Write."
Overflow::usage = "Overflow[] is the result of a numerical calculation whose result is too large to represent."
Overlaps::usage = "Overlaps is an option to StringPosition. With Overlaps -> True, substrings that overlap are included; with Overlaps -> False, they are not."
OwnValues::usage = "OwnValues[f] gives a list of transformation rules corresponding to all ownvalues (values for f itself) defined for the symbol f."
$Packages::usage = "$Packages gives a list of the contexts corresponding to all packages which have been loaded in your current Mathematica session."
PaddedForm::usage = "PaddedForm[expr, n] prints with all numbers in expr padded to leave room for a total of n digits. PaddedForm[expr, {n, f}] prints with approximate real numbers having exactly f digits to the right of the decimal point."
PageHeight::usage = "PageHeight is an option for output streams. PageHeight -> n specifies that n lines of text should be printed between page breaks. With PageHeight -> Infinity, there are no page breaks."
PageWidth::usage = "PageWidth is an option which can be set for output streams. PageWidth -> n specifies that each line of printed text can be n characters. With PageWidth -> Infinity, individual lines can be arbitrarily long."
ParametricPlot::usage = "ParametricPlot[{fx, fy}, {t, tmin, tmax}] produces a parametric plot with x and y coordinates fx and fy generated as a function of t. ParametricPlot[{{fx, fy}, {gx, gy}, ...}, {t, tmin, tmax}] plots several parametric curves."
ParametricPlot3D::usage = "ParametricPlot3D[{fx, fy, fz}, {t, tmin, tmax}] produces a three-dimensional space curve parameterized by a variable t which runs from tmin to tmax. ParametricPlot3D[{fx, fy, fz}, {t, tmin, tmax}, {u, umin, umax}] produces a three-dimensional surface parametrized by t and u. ParametricPlot3D[{fx, fy, fz, s}, ...] shades the plot according to the color specification s. ParametricPlot3D[{{fx, fy, fz}, {gx, gy, gz}, ...}, ...] plots several objects together."
ParentDirectory::usage = "ParentDirectory[ ] gives the parent of the current working directory. ParentDirectory[\"dir\"] gives the parent of the directory dir."
$ParentLink::usage = "$ParentLink is the LinkObject through which Mathematica communicates with a frontend in mathlink mode. It is assigned implicitly when Mathematica is started with a -mathlink command line option, or can be assigned explicitly. Assigning $ParentLink to Null resets the normal (terminal) mode."
Part::usage = "expr[[i]] or Part[expr, i] gives the ith part of expr. expr[[-i]] counts from the end. expr[[0]] gives the head of expr. expr[[i, j, ...]] or Part[expr, i, j, ...] is equivalent to expr[[i]] [[j]] .... expr[[ {i1, i2, ...} ]] gives a list of the parts i1, i2, ... of expr."
Partition::usage = "Partition[list, n] partitions list into non-overlapping sublists of length n. Partition[list, n, d] generates sublists with offset d. Partition[list, {n1, n2, ...}, {d1, d2, ...}] partitions successive levels in list into length ni sublists with offsets di."
PartitionsP::usage = "PartitionsP[n] gives the number p(n) of unrestricted partitions of the integer n."
PartitionsQ::usage = "PartitionsQ[n] gives the number q(n) of partitions of the integer n into distinct parts."
$Path::usage = "$Path gives a list of directories to search in attempting to find an external file."
$PathnameSeparator::usage = "$PathnameSeparator is a string that should separate the names of directories and files in pathnames used by this operating system."
Pattern::usage = "s:obj represents the pattern object obj, assigned the name s."
PatternTest::usage = "p?test is a pattern object that stands for any expression which matches p, and on which the application of test gives True."
Pause::usage = "Pause[n] pauses for at least n seconds."
Permutations::usage = "Permutations[list] generates a list of all possible permutations of the elements in list."
Pi::usage = "Pi is pi, with numerical value 3.14159...."
$PipeSupported::usage = "$PipeSupported is True if pipes can be used in the version of Mathematica you are running, and is False otherwise."
Pivoting::usage = "Pivoting is an option to certain matrix decomposition functions. With Pivoting -> False, no pivoting is done. With Pivoting -> True, column pivoting is carried out and the list of matrices returned is augmented by the appropriate permutation matrix."
Plain::usage = "Plain is a setting that can be given for the option TextRendering to specify output on a character-oriented display device. The TextRendering option is not supported in Version 2.0."
Play::usage = "Play[f, {t, tmin, tmax}] plays a sound whose amplitude is given by f as a function of time t in seconds between tmin and tmax."
PlayRange::usage = "PlayRange is an option for Play and related functions. With PlayRange -> All, all sound amplitude levels are included. PlayRange -> {amin, amax} specifies an explicit amplitude range. PlayRange -> Automatic drops outlying amplitude levels."
Plot::usage = "Plot[f, {x, xmin, xmax}] generates a plot of f as a function of x from xmin to xmax. Plot[{f1, f2, ...}, {x, xmin, xmax}] plots several functions fi."
PlotColor::usage = "PlotColor is an obsolete graphics option, superseded by ColorOutput."
PlotDivision::usage = "PlotDivision is an option for Plot. PlotDivision -> n specifies that a maximum of n subdivisions should be used in attempting to generate a smooth curve."
PlotJoined::usage = "PlotJoined is an option for ListPlot. With PlotJoined -> True, the points plotted are joined by a line. With PlotJoined -> False, they are not."
PlotLabel::usage = "PlotLabel is an option for graphics functions that specifies an overall label for a plot. With PlotLabel -> None, no label is given. PlotLabel -> label specifies a label."
PlotPoints::usage = "PlotPoints is an option for plotting functions. With a single variable, PlotPoints -> n uses a total of n sample points. With two variables, PlotPoints -> n specifies that n points should be used in both the x and y directions, and PlotPoints -> {nx, ny} specifies different numbers of sample points for the two directions."
PlotRange::usage = "PlotRange is an option for graphics functions. With PlotRange -> All, all points are included in the plot. With PlotRange -> Automatic, outlying points are dropped. PlotRange -> {min, max} specifies explicit limits for y (2D) or z (3D). PlotRange -> {{xmin, xmax}, ... } gives explicit limits for each coordinate."
PlotRegion::usage = "PlotRegion is an option for graphics functions. PlotRegion -> {{sxmin, sxmax}, {symin, symax}} specifies the region in scaled coordinates that the plot should fill in the final display area. With PlotRegion -> Automatic, the plot fills the final display area."
PlotStyle::usage = "PlotStyle is an option for Plot, ParametricPlot and ListPlot. PlotStyle -> style specifies that all lines or points are to be generated with the specified graphics directive, or list of graphics directives. PlotStyle -> {{style1}, {style2}, ... } specifies that successive lines generated should use graphics directives style1, style2, ... ."
Plot3D::usage = "Plot3D[f, {x, xmin, xmax}, {y, ymin, ymax}] generates a three-dimensional plot of f as a function of x and y. Plot3D[{f, s}, {x, xmin, xmax}, {y, ymin, ymax}] generates a three-dimensional plot in which the height of the surface is specified by f, and the shading is specified by s."
Plot3Matrix::usage = "Plot3Matrix is an option to Graphics3D and related functions that can be used to specify the explicit homogeneous perspective transformation matrix."
Plus::usage = "x + y + z represents a sum of terms."
Pochhammer::usage = "Pochhammer[a, n] gives the Pochhammer symbol."
Point::usage = "Point[coords] is a graphics primitive that represents a point."
PointForm::usage = "PointForm[g] is a three-dimensional graphics directive that specifies that points are to be drawn with the graphics directive g or the list of graphics directives g."
PointSize::usage = "PointSize[r] is a graphics directive which specifies that points which follow are to be shown if possible as circular regions with radius r. The radius r is given as a fraction of the total width of the graph."
PolyGamma::usage = "PolyGamma[z] gives the digamma function psi(z). PolyGamma[n, z] gives nth derivative of the digamma function."
Polygon::usage = "Polygon[{pt1, pt2, ...}] is a graphics primitive that represents a filled polygon."
PolygonIntersections::usage = "PolygonIntersections is an option for Graphics3D and ParametricPlot3D. With PolygonIntersections -> True, intersecting polygons are left unchanged. With PolygonIntersections -> False, Graphics3D objects are modified by breaking polygons into smaller pieces which do not intersect each other."
PolyLog::usage = "PolyLog[n, z] gives the nth polylogarithm function of z."
PolynomialDivision::usage = "PolynomialDivision[p, q, x] gives a list of the quotient and remainder obtained by division of the polynomials p and q in x."
PolynomialGCD::usage = "PolynomialGCD[poly1, poly2, ...] gives the greatest common divisor of the polynomials poly1, poly2, ... . PolynomialGCD[poly1, poly2, ..., Modulus->p] gives the GCD modulo the prime p."
PolynomialLCM::usage = "PolynomialLCM[poly1, poly2, ...] gives the least common multiple of the polynomials poly1, poly2, ... . PolynomialLCM[poly1, poly2, ..., Modulus->p] gives the LCM modulo the prime p."
PolynomialMod::usage = "PolynomialMod[poly, m] gives the polynomial poly reduced modulo m. PolynomialMod[poly, {m1, m2, ...}] reduces modulo all of the mi."
PolynomialQ::usage = "PolynomialQ[expr, var] yields True if expr is a polynomial in var, and yields False otherwise. PolynomialQ[expr, {var1, ...}] tests whether expr is a polynomial in the vari."
PolynomialQuotient::usage = "PolynomialQuotient[p, q, x] gives the quotient of p and q, treated as polynomials in x, with any remainder dropped."
PolynomialRemainder::usage = "PolynomialRemainder[p, q, x] gives the remainder from dividing p by q, treated as polynomials in x."
Position::usage = "Position[expr, pattern] gives a list of the positions at which objects matching pattern appear in expr. Position[expr, pattern, levspec] finds only objects that appear on levels specified by levspec."
Positive::usage = "Positive[x] gives True if x is a positive number."
$Post::usage = "$Post is a global variable whose value, if set, is applied to every output expression."
Postfix::usage = "Postfix[f[expr]] prints with f[expr] given in default postfix form: expr // f. Postfix[f[expr], h] prints as exprh."
PostScript::usage = "PostScript[\"string1\", \"string2\", ...] is a graphics primitive which specifies PostScript code to include verbatim in graphics output."
Power::usage = "x^y gives x to the power y."
PowerExpand::usage = "PowerExpand[expr] expands nested powers, powers of products, logarithms of powers, and logarithms of products. PowerExpand[expr, {x1, x2, ...}] expands expr with respect to the x1. Use PowerExpand with caution because PowerExpand does not pay attention to branch cuts."
$Pre::usage = "$Pre is a global variable whose value, if set, is applied to every input expression."
PrecedenceForm::usage = "PrecedenceForm[expr, prec] prints with expr parenthesized as it would be if it contained an operator with precedence prec."
Precision::usage = "Precision[x] gives the number of digits of precision in the number x."
PrecisionGoal::usage = "PrecisionGoal is an option for various numerical operations which specifies how many digits of precision should be sought in the final result. The error is considered acceptable and the result is returned when either the AccuracyGoal or the PrecisionGoal is achieved. PrecisionGoal -> Automatic yields a precision goal equal to 10 digits less than the setting for WorkingPrecision. With PrecisionGoal -> Infinity, precision is not used as the criterion for terminating the numerical procedure. Even though you may specify PrecisionGoal -> n, the results you get may have much less than n-digit precision."
PreDecrement::usage = "--x decreases the value of x by 1, returning the new value of x."
Prefix::usage = "Prefix[f[expr]] prints with f[expr] given in default prefix form: f @ expr. Prefix[f[expr], h] prints as hexpr."
PreIncrement::usage = "++x increases the value of x by 1, returning the new value of x."
Prepend::usage = "Prepend[expr, elem] gives expr with elem prepended."
PrependTo::usage = "PrependTo[s, elem] prepends elem to the value of s, and resets s to the result."
$PrePrint::usage = "$PrePrint is a global variable whose value, if set, is applied to every expression before it is printed."
$PreRead::usage = "$PreRead is a global variable whose value, if set, is applied to the text of every input expression before it is fed to Mathematica."
Prime::usage = "Prime[n] gives the nth prime number."
PrimePi::usage = "PrimePi[x] gives the number of primes less than or equal to x."
PrimeQ::usage = "PrimeQ[expr] yields True if expr is a prime number, and yields False otherwise. In the current version of Mathematica, the algorithm used for large integers is probabilistic, but very reliable (pseudoprime test and Lucas test)."
Print::usage = "Print[expr1, expr2, ...] prints the expri, followed by a newline (line feed)."
PrintForm::usage = "PrintForm[expr] returns the internal printform representation of expr."
$PrintForms::usage = "$PrintForms is the list of basic print forms. It is automatically updated when Format definitions using new printforms are made."
$PrintLiteral::usage = "$PrintLiteral is an internal symbol."
Product::usage = "Product[f, {i, imax}] evaluates the product of f with i running from 1 to imax. Product[f, {i, imin, imax}] starts with i = imin. Product[f, {i, imin, imax, di}] uses steps di. Product[f, {i, imin, imax}, {j, jmin, jmax}, ...] evaluates a multiple product."
Prolog::usage = "Prolog is an option for graphics functions which gives a list of graphics primitives to be rendered before the main part of the graphics is rendered."
PromptForm::usage = "PromptForm[prompt,expr] prints as an output prompt and expression."
Protect::usage = "Protect[s1, s2, ...] sets the attribute Protected for the symbols si. Protect[\"form1\", \"form2\", ...] protects all symbols whose names match any of the string patterns formi."
Protected::usage = "Protected is an attribute which prevents any values associated with a symbol from being modified."
PseudoInverse::usage = "PseudoInverse[m] finds the pseudoinverse of a rectangular matrix."
Put::usage = "expr >> filename writes expr to a file. Put[expr1, expr2, ..., \"filename\"] writes a sequence of expressions expri to a file."
PutAppend::usage = "expr >>> filename appends expr to a file. PutAppend[expr1, expr2, ..., \"filename\"] appends a sequence of expressions expri to a file."
QRDecomposition::usage = "QRDecomposition[m] yields the QR decomposition for a numerical matrix m. The result is a list {q, r}, where q is an orthogonal matrix, r is an upper triangular matrix, and m can be written as Conjugate[Transpose[q]].r."
Quartics::usage = "Quartics is an option for Roots and related functions. With Quartics -> True, explicit solutions are generated for irreducible quartic equations. With Quartics -> False, they are not."
Quit::usage = "Quit[ ] terminates a Mathematica session."
Quotient::usage = "Quotient[n, m] gives the integer quotient of n and m, defined as Floor[n/m]."
Random::usage = "Random[ ] gives a uniformly distributed pseudorandom Real in the range 0 to 1. Random[type, range] gives a pseudorandom number of the specified type, lying in the specified range. Possible types are: Integer, Real and Complex. The default range is 0 to 1. You can give the range {min, max} explicitly; a range specification of max is equivalent to {0, max}."
$RandomState::usage = "$RandomState is the current state of the random number generator represented as a large integer."
Range::usage = "Range[imax] generates the list {1, 2, ..., imax}. Range[imin, imax] generates the list {imin, ..., imax}. Range[imin, imax, di] uses step di."
Raster::usage = "Raster[{{a11, a12, ...}, ...}] is a two-dimensional graphics primitive which represents a rectangular array of gray cells."
RasterArray::usage = "RasterArray[{{g11, g12, ...}, ...}] is a two-dimensional graphics primitive which represents a rectangular array of cells colored according to the graphics directives gij."
Rational::usage = "Rational is the head used for rational numbers."
Rationalize::usage = "Rationalize[x] takes Real numbers in x that are close to rationals, and converts them to exact Rational numbers. Rationalize[x, dx] performs the conversion whenever the error made is smaller in magnitude than dx."
Raw::usage = "Raw[h, \"hexstring\"] constructs a raw data object with head h, and with contents corresponding to the binary bit pattern represented by the string hexstring, interpreted as a hexadecimal number."
RawMedium::usage = "RawMedium is an internal symbol."
Re::usage = "Re[z] gives the real part of the complex number z."
Read::usage = "Read[stream] reads one expression from an input stream, and returns the expression. Read[stream, type] reads one object of the specified type. Read[stream, {type1, type2, ...}] reads a sequence of objects of the specified types."
ReadList::usage = "ReadList[\"file\"] reads all the remaining expressions in a file, and returns a list of them. ReadList[\"file\", type] reads objects of the specified type from a file, until the end of the file is reached. The list of objects read is returned. ReadList[\"file\", {type1, type2, ...}] reads objects with a sequence of types, until the end of the file is reached. ReadList[\"file\", types, n] reads only the first n objects of the specified types."
ReadProtected::usage = "ReadProtected is an attribute which prevents values associated with a symbol from being seen."
Real::usage = "Real is the head used for real (floating-point) numbers."
RealBlockForm::usage = "RealBlockForm is an option of SchurDecomposition which specifies whether complex eigenvalues of a real input matrix should be returned as 2x2 real blocks or as complex values."
RealDigits::usage = "RealDigits[x] gives a list of the digits in the approximate real number x, together with the number of digits that appear to the left of the decimal point in scientific notation. RealDigits[x, b] gives a list of base-b digits in x."
RealInterval::usage = "RealInterval is an obsolete function, superseded by Interval."
Record::usage = "Record represents a record in Read, Find and related functions."
RecordLists::usage = "RecordLists is an option for ReadList. With RecordLists -> True, ReadList returns a list containing a sublist for each separate record it reads. With RecordLists -> False, ReadList returns a single list of all objects it reads."
RecordSeparators::usage = "RecordSeparators is an option for Read, Find and related functions which specifies the list of strings to be taken as delimiters for records. The default setting is RecordSeparators -> {\"\n\"}. RecordSeparators -> { } specifies that everything is to be included in a single record. RecordSeparators -> {{lsep1, ... }, {rsep1, ... }} specifies different left and right separators for records."
Rectangle::usage = "Rectangle[{xmin, ymin}, {xmax, ymax}] is a two-dimensional graphics primitive that represents a filled rectangle, oriented parallel to the axes. Rectangle[{xmin, ymin}, {xmax, ymax}, graphics] gives a rectangle filled with the specified graphics."
$RecursionLimit::usage = "$RecursionLimit gives the current limit on the number of levels of recursion that Mathematica can use."
Reduce::usage = "Reduce[eqns, vars] simplifies the equations eqns, attempting to solve for the variables vars. The equations generated by Reduce are equivalent to eqns, and contain all the possible solutions. Any variable in eqns but not vars is regarded as a parameter. Reduce[eqns] treats all variables encountered as vars above. Reduce[eqns, vars, elims] simplifies the equations, trying to eliminate the variables elims."
Reinstall::usage = "Reinstall[link] un-installs the specified external package and installs it again."
Release::usage = "Release is provided for backward compatibility only; its two independent functions are now provided by Evaluate and ReleaseHold. f[..., Release[expr], ...] is equivalent to f[..., Evaluate[expr], ...], which evaluates expr even if f would otherwise Hold expr in that position. Evaluation of Release[expr] removes the outer Hold from expr, or from its head and arguments; the similar function ReleaseHold is recommended."
ReleaseHold::usage = "ReleaseHold[expr] removes Hold and HoldForm in expr."
$ReleaseNumber::usage = "$ReleaseNumber is an integer which gives the current Mathematica kernel release number, and increases in successive releases."
$Remote::usage = "$Remote is True if Mathematica is being used in remote mode or with a front end, and is False otherwise."
Remove::usage = "Remove[symbol1, ...] removes symbols completely, so that their names are no longer recognized by Mathematica. Remove[\"form1\", \"form2\", ...] removes all symbols whose names match any of the string patterns formi."
Removed::usage = "Removed[string] is printed to indicated a symbol that has been removed."
RenameDirectory::usage = "RenameDirectory[\"dir1\", \"dir2\"] renames the directory dir1 to dir2."
RenameFile::usage = "RenameFile[\"file1\", \"file2\"] renames file1 to file2."
RenderAll::usage = "RenderAll is an option to Graphics3D. When RenderAll -> False, PostScript will be generated only for those polygons or parts of polygons which are visible in the final picture. If RenderAll -> True, PostScript is generated for all polygons."
Repeated::usage = "p.. is a pattern object which represents a sequence of one or more expressions, each matching p."
RepeatedNull::usage = "p... is a pattern object which represents a sequence of zero or more expressions, each matching p."
RepeatedString::usage = "RepeatedString is an internal symbol used for formatting and printing."
Replace::usage = "Replace[expr, rules] applies a rule or list of rules in an attempt to transform the entire expression expr."
ReplaceAll::usage = "expr /. rules applies a rule or list of rules in an attempt to transform each subpart of an expression expr."
ReplaceHeldPart::usage = "ReplaceHeldPart[expr, Hold[new], n] yields an expression in which the nth part of expr is replaced by new. ReplaceHeldPart[expr, Hold[new], {i, j, ...}] replaces the part at position {i, j, ...}. ReplaceHeldPart[expr, Hold[new], {{i1, j1, ...}, {i2, j2, ...}, ...}] replaces parts at several positions by new."
ReplacePart::usage = "ReplacePart[expr, new, n] yields an expression in which the nth part of expr is replaced by new. ReplacePart[expr, new, {i, j, ...}] replaces the part at position {i, j, ...}. ReplacePart[expr, new, {{i1, j1, ...}, {i2, j2, ...}, ...}] replaces parts at several positions by new."
ReplaceRepeated::usage = "expr //. rules repeatedly performs replacements until expr no longer changes."
ResetDirectory::usage = "ResetDirectory[ ] resets the current working directory to its previous value."
ResetMedium::usage = "ResetMedium[\"file\", options] resets the options associated with a file that is already open. ResetMedium[options] resets the options for the standard output. It is recommended that you use SetOptions in Version 2.0."
Residue::usage = "Residue[expr, {x, x0}] finds the residue of expr at the point x = x0."
Rest::usage = "Rest[expr] gives expr with the first element removed."
Resultant::usage = "Resultant[poly1, poly2, var] computes the resultant of the polynomials poly1 and poly2 with respect to the variable var. Resultant[poly1, poly2, var, Modulus->p] computes the resultant modulo the prime p."
Return::usage = "Return[expr] returns the value expr from a function. Return[ ] returns the value Null."
Reverse::usage = "Reverse[expr] reverses the order of the elements in expr."
RGBColor::usage = "RGBColor[red, green, blue] is a graphics directive which specifies that graphical objects which follow are to be displayed, if possible, in the color given."
RiemannSiegelTheta::usage = "RiemannSiegelTheta[t] gives the analytic function theta(t) which satisfies RiemannSiegelZ[t] == Exp[I RiemannSiegelTheta[t]] Zeta[1/2 + I t]. The argument t need not be real, but if it is, then RiemannSiegelTheta[t]] == Im[LogGamma[1/4 + I t/2]] - t Log[Pi]/2."
RiemannSiegelZ::usage = "RiemannSiegelZ[t] gives the function Exp[I RiemannSiegelTheta[t]] Zeta[1/2 + I t]."
Right::usage = "Right is used to specify alignment in printforms such as ColumnForm and TableForm."
Roots::usage = "Roots[lhs==rhs, var] yields a disjunction of equations which represent the roots of a polynomial equation."
RotateLabel::usage = "RotateLabel is an option for two-dimensional graphics functions. With RotateLabel -> True, labels on vertical frame axes are rotated to be vertical. With RotateLabel -> False, they are not."
RotateLeft::usage = "RotateLeft[expr, n] cycles the elements in expr n positions to the left. RotateLeft[expr] cycles one position to the left. RotateLeft[expr, {n1, n2, ...}] cycles elements at successive levels ni positions to the left."
RotateRight::usage = "RotateRight[expr, n] cycles the elements in expr n positions to the right. RotateRight[expr] cycles one position to the right. RotateRight[expr, {n1, n2, ...}] cycles elements at successive levels ni positions to the right."
Round::usage = "Round[x] gives the integer closest to x."
Row::usage = "Row is a setting for the TableDirections option of TableForm."
RowReduce::usage = "RowReduce[m] gives the row-reduced form of the matrix m."
Rule::usage = "lhs -> rhs represents a rule that transforms lhs to rhs."
RuleCondition::usage = "RuleCondition is an internal symbol."
RuleDelayed::usage = "lhs :> rhs represents a rule that transforms lhs to rhs, evaluating rhs only when the rule is used."
RuleForm::usage = "RuleForm is an internal symbol used for formatting and printing."
RuleTable::usage = "RuleTable is an internal symbol."
Run::usage = "Run[expr1, expr2, ...] generates the printed form of the expressions expri, separated by spaces, and runs it as an external, operating system, command."
RunThrough::usage = "RunThrough[\"command\", expr] executes an external command, giving the printed form of expr as input, and taking the output, reading it as Mathematica input, and returning the result."
SameQ::usage = "lhs === rhs yields True if the expression lhs is identical to rhs, and yields False otherwise."
SameTest::usage = "SameTest is an option for functions like FixedPoint that specifies the comparison function to apply to pairs of results to determine whether they should be considered the same. Settings for SameTest must be functions that take two arguments, and return True or False."
SampleDepth::usage = "SampleDepth is an option for sound primitives. SampleDepth -> n specifies that n bits should be used to encode sound amplitude levels."
SampledSoundFunction::usage = "SampledSoundFunction[f, n, r] is a sound primitive, which represents a sound whose amplitude sampled r times a second is generated by applying the function f to successive integers from 1 to n."
SampledSoundList::usage = "SampledSoundList[{a1, a2, ...}, r] is a sound primitive, which represents a sound whose amplitude has levels ai sampled r times a second."
SampleRate::usage = "SampleRate is an option for sound primitives. SampleRate -> n specifies that n samples per second should be used to generate sounds."
Save::usage = "Save[\"filename\", symb1, symb2, ...] appends the definitions of the symbols symbi to a file."
Scaled::usage = "Scaled[{x, y, ...}] gives the position of a graphical object in terms of coordinates scaled to run from 0 to 1 across the whole plot in each direction. Scaled[{dx, dy, ...}, {x0, y0, ...}] gives a position obtained by starting at absolute coordinates {x0, y0, ...}, then moving by a scaled offset {dx, dy, ...}."
Scan::usage = "Scan[f, expr] evaluates f applied to each element of expr in turn. Scan[f, expr, levelspec] applies f to parts of expr specified by levelspec."
SchurDecomposition::usage = "SchurDecomposition[m] yields the Schur decomposition for a numerical matrix m. The result is a list {q, t} where q is an orthogonal matrix and t is a block upper triangular matrix."
ScientificForm::usage = "ScientificForm[expr] prints with all real numbers in expr given in scientific notation."
Sec::usage = "Sec[z] gives the secant of z."
Sech::usage = "Sech[z] gives the hyperbolic secant of z."
Second::usage = "Second is a unit of time used by functions such as Timing."
SeedRandom::usage = "SeedRandom[n] resets the pseudorandom number generator, using the integer n as a seed. SeedRandom[ ] resets the generator, using as a seed the time of day."
Select::usage = "Select[list, crit] picks out all elements ei of list for which crit[ei] is True. Select[list, crit, n] picks out the first n elements for which crit[ei] is True."
Sequence::usage = "Sequence[e1,e2,...] is a special form representing a sequence of arguments in an expression."
SequenceForm::usage = "SequenceForm[expr1, expr2, ...] prints as the textual concatenation of the printed forms of the expri."
SequenceLimit::usage = "SequenceLimit[list] returns the approximation given by Wynn's epsilon algorithm to the limit of a sequence whose first few terms are given by list. Warning: Wynn's epsilon algorithm can give finite results for divergent sequences."
Series::usage = "Series[f, {x, x0, n}] generates a power series expansion for f about the point x = x0 to order (x - x0)^n. Series[f, {x, x0, nx}, {y, y0, ny}] successively finds series expansions with respect to y, then x."
SeriesCoefficient::usage = "SeriesCoefficient[s,n] returns the coefficient of the n-th power of the variable in the series s."
SeriesData::usage = "SeriesData[x, x0, {a0, a1, ...}, nmin, nmax, den] represents a power series in the variable x about the point x0. The ai are the coefficients in the power series. The powers of (x-x0) that appear are nmin/den, (nmin+1)/den, ..., nmax/den."
$SessionID::usage = "$SessionID is a number set up to be unique to a particular Mathematica session."
SessionTime::usage = "SessionTime[ ] gives the total number of seconds of real time that have elapsed since the beginning of your Mathematica session."
Set::usage = "lhs = rhs evaluates rhs and assigns the result to be the value of lhs. From then on, lhs is replaced by rhs whenever it appears. {l1, l2, ...} = {r1, r2, ...} evaluates the ri, and assigns the results to be the values of the corresponding li."
SetAccuracy::usage = "SetAccuracy[expr, n] yields a version of expr in which all numbers have been set to have an accuracy of n digits."
SetAttributes::usage = "SetAttributes[s, attr] adds attr to the list of attributes of the symbol s."
SetDelayed::usage = "lhs := rhs assigns rhs to be the delayed value of lhs. rhs is maintained in an unevaluated form. When lhs appears, it is replaced by rhs, evaluated afresh each time."
SetDirectory::usage = "SetDirectory[\"dir\"] sets the current working directory."
SetFileDate::usage = "SetFileDate[\"file\"] sets the modification date for a file to be the current date. SetFileDate[\"file\", date] sets the modification date to be the specified date. The date must be given in the {year, month, day, hour, minute, second} format used by Date."
SetOptions::usage = "SetOptions[s, name1->value1, name2->value2, ...] sets the specified default options for a symbol s. SetOptions[stream, ...] or SetOptions[\"name\", ...] sets options associated with a particular stream."
SetPrecision::usage = "SetPrecision[expr, n] yields a version of expr in which all numbers have been set to have a precision of n digits."
SetStreamPosition::usage = "SetStreamPosition[stream, n] sets the current point in an open stream."
Shading::usage = "Shading is an option for SurfaceGraphics. With Shading -> True, surfaces are shaded. With Shading -> False, they are not."
Shallow::usage = "Shallow[expr] prints as a shallow form of expr. Shallow[expr, depth] prints with all parts of expr below the specified depth given in skeleton form. Shallow[expr, {depth, length}] also gives parts whose lengths are above the specified limit in skeleton form. Shallow[expr, {depth, length}, form] uses skeleton form for any parts which match the pattern form."
Share::usage = "Share[expr] changes the way expr is stored internally, to try and minimize the amount of memory used. Share[ ] tries to minimize the memory used to store all expressions."
Short::usage = "Short[expr] prints as a short form of expr, less than about one line long. Short[expr, n] prints as a form of expr about n lines long."
Show::usage = "Show[graphics, options] displays two- and three-dimensional graphics, using the options specified. Show[g1, g2, ...] shows several plots combined. Show can also be used to play Sound objects."
Sign::usage = "Sign[x] gives -1, 0 or 1 depending on whether x is negative, zero, or positive. Sign[z] gives the sign of the complex number z."
Signature::usage = "Signature[list] gives the signature of the permutation needed to place the elements of list in canonical order."
SignPadding::usage = "SignPadding is an option for NumberForm and related functions. With SignPadding -> True, padding that is needed is inserted between the sign and the digits in a number. With SignPadding -> False, the padding is inserted before the sign."
Simplify::usage = "Simplify[expr] performs a sequence of transformations on expr, and returns the simplest form it finds."
SimplifyGamma::usage = "SimplifyGamma[expr] performs a sequence of gamma-function transformations on expr, and returns the simplest form it finds."
SimplifyPolyGamma::usage = "SimplifyPolyGamma[expr] performs a sequence of polygamma-function transformations on expr, and returns the simplest form it finds."
Sin::usage = "Sin[z] gives the sine of z."
SingularityDepth::usage = "SingularityDepth is an option for NIntegrate. SingularityDepth -> n specifies that n recursive subdivisions can be done before a change of variable is used at the endpoints of the interval of integration."
SingularValues::usage = "SingularValues[m] gives the singular value decomposition for a numerical matrix m. The result is a list {u, w, v}, where w is the list of nonzero singular values, and m can be written as Conjugate[Transpose[u]].DiagonalMatrix[w].v."
Sinh::usage = "Sinh[z] gives the hyperbolic sine of z."
SinhIntegral::usage = "SinhIntegral[x] gives the hyperbolic sine integral Integrate[Sinh[t]/t, {t, 0, x}]."
SinIntegral::usage = "SinIntegral[x] gives the sine integral Integrate[Sin[t]/t, {t, 0, x}]."
SixJSymbol::usage = "The SixJSymbol[{a,b,e},{d,e,f}] returns the value of the 6-j symbol."
Skeleton::usage = "Skeleton[n] represents a sequence of n omitted elements in an expression printed with Short or Shallow. The standard print form for Skeleton is <<n>>."
Skip::usage = "Skip[stream, type] skips one object of the specified type in an input stream. Skip[stream, type, n] skips n objects of the specified type."
Slot::usage = "# represents the first argument supplied to a pure function. #n represents the nth argument."
SlotSequence::usage = "## represents the sequence of arguments supplied to a pure function. ##n represents the sequence of arguments supplied to a pure function, starting with the nth argument."
Socket::usage = "Socket is a possible value returned by FileType and related functions."
SolutionOf::usage = "SolutionOf is an internal symbol."
Solve::usage = "Solve[eqns, vars] attempts to solve an equation or set of equations for the variables vars. Any variable in eqns but not vars is regarded as a parameter. Solve[eqns] treats all variables encountered as vars above. Solve[eqns, vars, elims] attempts to solve the equations for vars, eliminating the variables elims."
SolveAlways::usage = "SolveAlways[eqns, vars] gives the values of parameters that make the equations eqns valid for all values of the variables vars."
Sort::usage = "Sort[list] sorts the elements of list into canonical order. Sort[list, p] sorts using the ordering function p."
Sound::usage = "Sound[primitives] represents a sound."
$SoundDisplayFunction::usage = "$SoundDisplayFunction gives the default setting for the option DisplayFunction in sound functions."
Space::usage = "Space is a string consisting of a space."
SpaceForm::usage = "SpaceForm[n] prints as n spaces."
SpellingCorrection::usage = "SpellingCorrection is an option for StringMatchQ, Names and related functions. With SpellingCorrection -> True, strings are considered to match even when a small fraction of the characters in them are different. SpellingCorrection -> False requires exact matching."
SphericalHarmonicY::usage = "SphericalHarmonicY[l, m, theta, phi] gives the spherical harmonic Ylm(theta, phi)."
SphericalRegion::usage = "SphericalRegion is an option for three-dimensional graphics functions. With SphericalRegion -> True, the final image is scaled so that a sphere drawn around the three-dimensional bounding box will fit in the display area specified. SphericalRegion -> False scales three-dimensional images to be as large as possible, given the display area specified."
Splice::usage = "Splice[\"file\"] splices Mathematica output into an external file. It takes text enclosed between <* and *> in the file, evaluates the text as Mathematica input, and replaces the text with the resulting Mathematica output."
Sqrt::usage = "Sqrt[z] gives the square root of z."
Stack::usage = "Stack[ ] shows the current evaluation stack, giving a list of the tags associated with evaluations that are currently being done. Stack[pattern] gives a list of expressions currently being evaluated which match the pattern."
StackBegin::usage = "StackBegin[expr] evaluates expr, starting a fresh evaluation stack."
StackComplete::usage = "StackComplete[expr] evaluates expr with intermediate expressions in evaluation chains included on the stack."
StackInhibit::usage = "StackInhibit[expr] evaluates expr without modifying the evaluation stack."
StartingStepSize::usage = "StartingStepSize is an option to NDSolve. StartingStepSize -> r specifies an initial step size of r."
StartProcess::usage = "StartProcess[\"command\"] starts up an external process in which functions can be called from Mathematica. (StartProcess has been superseded by MathLink operations.)"
StieltjesGamma::usage = "StieltjesGamma[n] is the nth Stieltjes constant and is related to the Laurent series expansion of Zeta[s] about s == 1."
StirlingS1::usage = "StirlingS1[n, m] gives the Stirling number of the first kind."
StirlingS2::usage = "StirlingS2[n, m] gives the Stirling number of the second kind."
StreamPosition::usage = "StreamPosition[stream] returns an integer which specifies the position of the current point in an open stream."
Streams::usage = "Streams[ ] gives a list of all streams that are currently open. Streams[\"name\"] lists only streams with the specified name."
String::usage = "String is the head of a character string \"text\"."
StringBreak::usage = "StringBreak[n] is output at the end of the nth line where a string is broken."
StringByteCount::usage = "StringByteCount[\"string\"] gives the total number of bytes used to store the characters in a string."
$StringConversion::usage = "$StringConversion gives the default setting for the option StringConversion in output functions."
StringConversion::usage = "StringConversion is an option for output functions. StringConversion -> None specifies that all special characters should be output without modification. StringConversion -> Automatic specifies that all special characters should be output using backslash sequences. StringConversion -> f specifies that the function f should be applied to convert all strings containing special characters. The default setting is StringConversion :> $StringConversion."
StringDrop::usage = "StringDrop[\"string\", n] gives \"string\" with its first n characters dropped. StringDrop[\"string\", -n] gives \"string\" with its last n characters dropped. StringDrop[\"string\", {n}] gives \"string\" with its nth character dropped. StringDrop[\"string\", {m, n}] gives \"string\" with characters m through n dropped."
StringForm::usage = "StringForm[\"controlstring\", expr1, ...] prints as the text of the controlstring, with the printed forms of the expri embedded."
StringInsert::usage = "StringInsert[\"string\", \"snew\", n] yields a string with \"snew\" inserted starting at position n in \"string\". StringInsert[\"string\", \"snew\", -n] inserts at position n from the end of \"string\"."
StringJoin::usage = "\"s1\" <> \"s2\" <> ..., StringJoin[\"s1\", \"s2\", ...] or StringJoin[{\"s1\", \"s2\", ...}] yields a string consisting of a concatenation of the si."
StringLength::usage = "StringLength[\"string\"] gives the number of characters in a string."
StringMatchQ::usage = "StringMatchQ[\"string\", \"pattern\"] yields True if \"string\" matches the specified string pattern, and yields False otherwise."
$StringOrder::usage = "$StringOrder gives the ordering of characters to be used in sorting strings and symbol names."
StringPosition::usage = "StringPosition[\"string\", \"sub\"] gives a list of the starting and ending character positions at which \"sub\" appears as a substring of \"string\". StringPosition[\"string\", \"sub\", k] includes only the first k occurrences of \"sub\". StringPosition[\"string\", {\"sub1\", \"sub2\", ...}] gives positions of all the \"subi\"."
StringQ::usage = "StringQ[expr] gives True if expr is a string, and False otherwise."
StringReplace::usage = "StringReplace[\"string\", \"s1\" -> \"sp1\"] or StringReplace[\"string\", {\"s1\" -> \"sp1\", \"s2\" -> \"sp2\", ...}] replaces the \"si\" by \"spi\" whenever they appear as substrings of \"string\"."
StringReverse::usage = "StringReverse[\"string\"] reverses the order of the characters in \"string\"."
StringSkeleton::usage = "StringSkeleton[n] represents a sequence of n omitted characters in a string printed with Short. The standard print form for StringSkeleton is an ellipsis."
StringTake::usage = "StringTake[\"string\", n] gives a string containing the first n characters in \"string\". StringTake[\"string\", -n] gives the last n characters in \"string\". StringTake[\"string\", {n}] gives the nth character in \"string\". StringTake[\"string\", {m, n}] gives characters m through n in \"string\"."
StringToStream::usage = "StringToStream[\"string\"] opens an input stream for reading from a string."
Stub::usage = "Stub is an attribute which specifies that if a symbol is ever used, Needs should automatically be called on the context of the symbol."
Subscript::usage = "Subscript[expr] prints expr as a subscript."
Subscripted::usage = "Subscripted[f[arg1, arg2, ...]] prints with the argi given as subscripts of f. Subscripted[expr, sub, sup] prints with the arguments specified by sub as subscripts, and the arguments specified by sup as superscripts. Arguments not included either in sub or sup are printed in standard functional form. The specification n takes the first n arguments. -n takes the last n arguments. {m, n} takes arguments m through n."
Subtract::usage = "x - y is equivalent to x + (-1 * y)."
SubtractFrom::usage = "x -= dx subtracts dx from x and returns the new value of x."
SubValues::usage = "SubValues[f] gives a list of transformation rules corresponding to all subvalues (values for f[x,..][..], etc.) defined for the symbol f."
Sum::usage = "Sum[f, {i, imax}] evaluates the sum of f with i running from 1 to imax. Sum[f, {i, imin, imax}] starts with i = imin. Sum[f, {i, imin, imax, di}] uses steps di. Sum[f, {i, imin, imax}, {j, jmin, jmax}, ...] evaluates a multiple sum."
Superscript::usage = "Superscript[expr] prints expr as a superscript."
$SuppressInputFormHeads::usage = "$SuppressInputFormHeads is a list of the heads of expressions whose InputForm should not be sent automatically to front ends."
SurfaceColor::usage = "SurfaceColor[dcol] is a three-dimensional graphics directive which specifies that the polygons which follow should act as diffuse reflectors of light with a color given by dcol. SurfaceColor[dcol, scol] specifies that a specular reflection component should be included, with a color given by scol. SurfaceColor[dcol, scol, n] specifies that the reflection should occur with specular exponent n."
SurfaceGraphics::usage = "SurfaceGraphics[array] is a representation of a three-dimensional plot of a surface, with heights of each point on a grid specified by values in array. SurfaceGraphics[array, shades] represents a surface, whose parts are shaded according to the array shades."
Switch::usage = "Switch[expr, form1, value1, form2, value2, ...] evaluates expr, then compares it with each of the formi in turn, evaluating and returning the valuei corresponding to the first match found."
Symbol::usage = "Symbol is the head associated with a symbol."
$SyntaxHandler::usage = "$SyntaxHandler is a global variable which, if set, is applied to any input string that is found to contain a syntax error. The arguments given to $SyntaxHandler are the complete input string and an integer specifying the character position at which the syntax error was detected."
SyntaxLength::usage = "SyntaxLength[\"string\"] finds the number of characters starting at the beginning of a string that correspond to syntactically correct input for a single Mathematica expression."
SyntaxQ::usage = "SyntaxQ[\"string\"] returns True if the string corresponds to syntactically correct input for a single Mathematica expression, and returns False otherwise."
$System::usage = "$System is a string specifying the type of computer system used."
Tab::usage = "Tab is a string consisting of a tab character."
Table::usage = "Table[expr, {imax}] generates a list of imax copies of expr. Table[expr, {i, imax}] generates a list of the values of expr when i runs from 1 to imax. Table[expr, {i, imin, imax}] starts with i = imin. Table[expr, {i, imin, imax, di}] uses steps di. Table[expr, {i, imin, imax}, {j, jmin, jmax}, ...] gives a nested list. The list associated with i is outermost."
TableAlignments::usage = "TableAlignments is an option for TableForm and MatrixForm. TableAlignments -> {a1, a2, ... } specifies alignments for successive dimensions. For dimensions that are given as columns, possible alignments are Left, Center and Right. For dimensions that are given as rows, possible alignments are Bottom, Center and Top. The default setting TableAlignments -> Automatic uses Left for column alignment, and Bottom for row alignment."
TableDepth::usage = "TableDepth is an option for TableForm and MatrixForm. TableDepth -> n prints elements in list below level n as ordinary lists, rather than arranging them in tabular form. With the default setting TableDepth -> Infinity, as many levels as possible are printed in tabular form."
TableDirections::usage = "TableDirections is an option for TableForm and MatrixForm. TableDirections -> Column specifies that successive dimensions should be arranged alternately as columns and rows, with the first dimension arranged as columns. TableDirections -> Row takes the first dimension to be arranged as rows. TableDirections -> {dir1, dir2, ... } specifies explicitly whether each dimension should be arranged with Column or Row."
TableForm::usage = "TableForm[list] prints with the elements of list arranged in an array of rectangular cells."
TableHeadings::usage = "TableHeadings is an option for TableForm and MatrixForm which gives the labels to be printed for entries in each dimension of a table or matrix. TableHeadings -> None gives no labels in any dimension. TableHeadings -> Automatic gives successive integer labels for each entry in each dimension. TableHeadings -> {{lab11, lab12, ... }, ... } gives explicit labels for each entry."
TableSpacing::usage = "TableSpacing is an option for TableForm and MatrixForm which specifies how many spaces should be left between each successive row or column. TableSpacing -> {s1, s2, ... } specifies that si spaces should be left in dimension i. For TableForm, TableSpacing -> Automatic yields spacings {1, 3, 0, 1, 0, 1, ... }."
TagSet::usage = "f/: lhs = rhs assigns rhs to be the value of lhs, and associates the assignment with the symbol f."
TagSetDelayed::usage = "f/: lhs := rhs assigns rhs to be the delayed value of lhs, and associates the assignment with the symbol f."
TagUnset::usage = "f/: lhs =. removes any rules defined for lhs, associated with the symbol f."
Take::usage = "Take[list, n] gives the first n elements of list. Take[list, -n] gives the last n elements of list. Take[list, {m, n}] gives elements m through n of list."
Tan::usage = "Tan[z] gives the tangent of z."
Tanh::usage = "Tanh[z] gives the hyperbolic tangent of z."
TargetFunctions::usage = "TargetFunctions is an option to ComplexExpand. The value can be given as a list chosen from {Re, Im, Abs, Arg, Conjugate, Sign}. ComplexExpand will try to return results in terms of the functions requested."
Temporary::usage = "Temporary is an attribute assigned to symbols which are created as local variables by Module."
$TemporaryPrefix::usage = "$TemporaryPrefix forms the initial part of filenames returned by OpenTemporary[]."
TensorRank::usage = "TensorRank[expr] gives the depth to which expr is a full array, with all the parts at a particular level being lists of the same length."
TeXForm::usage = "TeXForm[expr] prints as a TeX language version of expr."
Text::usage = "Text[expr, coords] is a graphics primitive that represents text corresponding to the printed form of expr, centered at the point specified by coords."
TextForm::usage = "TextForm[expr] prints as a textual form of expr."
TextRendering::usage = "TextRendering is an option for OpenWrite etc. which specifies how text is to be rendered in a particular output file. This option is not supported in Version 2.0."
Thickness::usage = "Thickness[r] is a graphics directive which specifies that lines which follow are to be drawn with a thickness r. The thickness r is given as a fraction of the total width of the graph."
$Thin::usage = "$Thin = True means that a thin Kernel has been started which use an autoloading mechanism to load system packages on demand."
ThisLink::usage = "ThisLink is used in patterns for external packages to distinguish between several instances of the same package."
Thread::usage = "Thread[f[args]] ``threads'' f over any lists that appear in args. Thread[f[args], h] threads f over any objects with head h that appear in args. Thread[f[args], h, n] threads f over objects with head h that appear in the first n args. Thread[f[args], h, -n] threads over the last n args. Thread[f[args], h, {m, n}] threads over arguments m through n."
ThreeJSymbol::usage = "ThreeJSymbol[{j1,m1},{j2,m2},{j3,m3}] evaluates the 3-j symbol. The ji may be symbolic and must satisfy triangularity conditions. Also note that m1+m2+m3 = 0."
Through::usage = "Through[p[f1, f2][x]] gives p[f1[x], f2[x]]. Through[expr, h] performs the transformation wherever h occurs in the head of expr."
$Throw::usage = "$Throw is an internal symbol."
Throw::usage = "Throw[expr] exits from nested control structures, returning the value expr to the nearest enclosing Catch."
Ticks::usage = "Ticks is an option for graphics functions. With Ticks -> None, no tick marks are drawn on the axes. With Ticks -> Automatic, tick marks are placed automatically. Ticks -> {xticks, yticks, ... } specifies tick mark options separately for each axis."
TimeConstrained::usage = "TimeConstrained[expr, t] evaluates expr, stopping after t seconds. TimeConstrained[expr, t, failexpr] returns failexpr if the time constraint is not met."
Times::usage = "x*y*z or x y z represents a product of terms."
TimesBy::usage = "x *= c multiplies x by c and returns the new value of x."
$TimeUnit::usage = "$TimeUnit gives the minimum time interval in seconds recorded on your computer system."
TimeUsed::usage = "TimeUsed[ ] yields the total number of seconds of CPU time used so far in the current Mathematica session."
TimeZone::usage = "TimeZone[ ] gives the time zone set for your computer system."
Timing::usage = "Timing[expr] evaluates expr, and returns a list of time used, together with the result obtained."
ToASCII::usage = "ToASCII is an obsolete function, superseded by ToCharacterCode.\n ToASCII[\"c\"] gives the ASCII integer code corresponding to the character c."
ToCharacterCode::usage = "ToCharacterCode[\"string\"] gives a list of the integer codes corresponding to the characters in a string."
ToColor::usage = "ToColor[ color, form] converts color to form if form is GrayLevel, RGBColor or CMYKColor color is converted into it. Otherwise form[ color] is evaluated and the result is expected to be a valid color directive."
ToDate::usage = "ToDate[time] converts an absolute time in seconds since the beginning of January 1, 1900 to a date of the form {y, m, d, h, m, s}."
ToExpression::usage = "ToExpression[\"string\"] gives the expression obtained by taking string as Mathematica input."
Together::usage = "Together[expr] puts terms in a sum over a common denominator, and cancels factors in the result."
ToHeldExpression::usage = "ToHeldExpression[\"string\"] gives the expression obtained by taking string as Mathematica input, enclosed in Hold[]."
TokenWords::usage = "TokenWords is an option for Read and related functions. The setting for TokenWords is a list of strings which are used as delimiters for words to be read."
Tolerance::usage = "Tolerance is an option to certain functions that specifies the numerical tolerance under which the calculation is to be effected. Tolerance -> r sets a tolerance of r."
ToLowerCase::usage = "ToLowerCase[string] yields a string in which all letters have been converted to lower case."
TooBig::usage = "TooBig is an internal symbol."
Top::usage = "Top is a setting for the TableAlignments option of TableForm."
ToRules::usage = "ToRules[eqns] takes logical combinations of equations, in the form generated by Reduce or Roots, and converts them to a sequence of lists of rules where the sequence corresponds to Or and the lists correspond to And. {ToRules[eqns]} gives a result of the form produced by Solve."
ToString::usage = "ToString[expr] gives a string corresponding to the printed form of expr. Options set the line width, format type, etc."
TotalHeight::usage = "TotalHeight is an option for output streams. Totalheight -> n specifies that a maximum of n lines of text should be printed for each output expression. Short forms of expressions are given if the number of lines needed to print the whole expression is too large. TotalHeight -> Infinity allows expressions of any length to be printed."
TotalWidth::usage = "TotalWidth is an option for output streams. TotalWidth -> n specifies that a maximum of n characters of text should be printed for each output expression. Short forms of expressions are given if the number of characters needed to print the whole expression is too large. TotalWidth -> Infinity allows expressions of any length to be printed."
ToUpperCase::usage = "ToUpperCase[string] yields a string in which all letters have been converted to upper case."
Trace::usage = "Trace[expr] generates a list of all expressions used in the evaluation of expr. Trace[expr, form] includes only those expressions which match form. Trace[expr, s] includes all evaluations which use transformation rules associated with the symbol s."
TraceAbove::usage = "TraceAbove is an option for Trace and related functions which specifies whether to include evaluation chains which contain the evaluation chain containing the pattern form sought. TraceAbove -> True includes the first and last expressions in all evaluation chains within which the evaluation chain containing form occurs. TraceAbove -> All includes all expressions in these evaluation chains. TraceAbove -> {backspec, forspec} allows you to specify separately which expressions to include in the backward and forward directions."
TraceAction::usage = "TraceAction is an option for TracePrint and TraceDialog that specifies the function to be applied to each expression they trace."
TraceBackward::usage = "TraceBackward is an option for Trace and related functions which specifies whether to include preceding expressions on the evaluation chain that contains the pattern sought. TraceBackward -> True includes the first expression on the evaluation chain. TraceBackward -> All includes all expressions on the evaluation chain before the pattern sought."
TraceDepth::usage = "TraceDepth is an option for Trace and related functions which specifies the maximum nesting of evaluation chains that are to be included. Setting TraceDepth -> n keeps only parts down to level n in nested lists generated by Trace."
TraceDialog::usage = "TraceDialog[expr] initiates a dialog for every expression used in the evaluation of expr. TraceDialog[expr, form] initiates a dialog only for expressions which match form. TraceDialog[expr, s] initiates dialogs only for expressions whose evaluations use transformation rules associated with the symbol s."
TraceForward::usage = "TraceForward is an option for Trace and related functions which specifies whether to include later expressions on the evaluation chain that contains the pattern sought. TraceForward -> True includes the final expression on the evaluation chain. TraceForward -> All includes all expressions on the evaluation chain after the pattern sought."
TraceInternal::usage = "TraceInternal is an option for Trace and related functions which, if True or False, specifies whether to trace evaluations of expressions generated internally by Mathematica. The intermediate Automatic setting traces a selected set of internal evaluations including Messages and sets or unsets of visible symbols."
TraceLevel::usage = "Whenever Trace[] or a related function is being evaluated, TraceLevel[] returns the level of its output currently being filled."
$TraceOff::usage = "$TraceOff is the currently active TraceOff option value to Trace and related functions. It can be reset during the trace to alter the set of expressions in which tracing is disabled."
TraceOff::usage = "TraceOff is an option for Trace and related functions. With TraceOff -> patt, tracing will be switched off while any expression matching the pattern patt is being evaluated. The default is TraceOn -> None."
$TraceOn::usage = "$TraceOn is the currently active TraceOn option value to Trace and related functions. It can be reset during the trace to alter the set of expressions in which tracing will occur."
TraceOn::usage = "TraceOn is an option for Trace and related functions. With TraceOn -> patt, Trace and related functions do not start tracing until they encounter expressions to evaluate which match the pattern patt. The default is TraceOn -> None."
TraceOriginal::usage = "TraceOriginal is an option for Trace and related functions. With TraceOriginal -> True, the form of each expression is tested before its head and arguments are evaluated. With TraceOriginal -> False, it is not."
$TracePattern::usage = "$TracePattern is the currently active pattern argument to Trace and related functions. It can be reset during the trace to alter the set of expressions recorded or printed."
$TracePostAction::usage = "$TracePostAction is the currently active fourth argument to TraceScan (or the equivalent in related functions). It can be reset during the trace to alter the action taken after intercepted expressions are evaluated."
$TracePreAction::usage = "$TracePreAction is the currently active first argument to TraceScan (or the equivalent in related functions). It can be reset during the trace to alter the action taken before intercepted expressions are evaluated."
TracePrint::usage = "TracePrint[expr] prints all expressions used in the evaluation of expr. TracePrint[expr, form] includes only those expressions which match form. TracePrint[expr, s] includes all evaluations which use transformation rules associated with the symbol s."
TraceScan::usage = "TraceScan[f, expr] applies f to all expressions used in the evaluation of expr. TraceScan[f, expr, form] includes only those expressions which match form. TraceScan[f, expr, s] includes all evaluations which use transformation rules associated with the symbol s. TraceScan[f, expr, form, fp] applies f before evaluation and fp after evaluation to expressions used in the evaluation of expr."
Transpose::usage = "Transpose[list] transposes the first two levels in list. Transpose[list, {n1, n2, ...}] transposes list so that the nk-th level in list is the k-th level in the result."
Trapezoidal::usage = "Trapezoidal is a choice for the option Method of NIntegrate. Method -> Trapezoidal causes a recursive trapezoidal algorithm to be used. This is particularly useful when the integrand is periodic and the interval of integration is exactly one period. For multi-dimensional integration Trapezoidal refers to a Cartesian product of one dimensional trapezoidal rules. "
TreeForm::usage = "TreeForm[expr] prints with different levels in expr shown at different depths."
Trig::usage = "Trig is an option for algebraic manipulation functions. With Trig -> True, trigonometric functions are treated as rational functions of exponentials. With Trig -> False, trigonometric functions are treated as indivisible objects."
True::usage = "True is the symbol for the Boolean value true."
TrueQ::usage = "TrueQ[expr] yields True if expr is True, and yields False otherwise."
Underflow::usage = "Underflow[] is the result of a numerical calculation whose result is too small to represent."
Unequal::usage = "lhs != rhs returns False if lhs and rhs are identical."
Unevaluated::usage = "Unevaluated[expr] represents the unevaluated form of expr when it appears as the argument to a function."
Uninstall::usage = "Uninstall[link] terminates an external program started by Install, and removes Mathematica definitions set up by it."
Union::usage = "Union[list1, list2, ...] gives a sorted list of all the distinct elements that appear in any of the listi. Union[list] gives a sorted version of a list, in which all duplicated elements have been dropped."
Unique::usage = "Unique[ ] generates a new symbol, whose name is of the form $nnn. Unique[x] generates a new symbol, with a name of the form x$nnn. Unique[{x, y, ...}] generates a list of new symbols. Unique[\"xxx\"] generates a new symbol, with a name of the form xxxnnn. Unique[name, {attr1, attr2, ...}] generates a symbol which has the attributes attri."
Unprotect::usage = "Unprotect[s1, s2, ...] removes the attribute Protected for the symbols si. Unprotect[\"form1\", \"form2\", ...] unprotects all symbols whose names textually match any of the formi."
UnsameQ::usage = "lhs =!= rhs yields True if the expression lhs is not identical to rhs, and yields False otherwise."
$Unset::usage = "$Unset is an internal symbol."
Unset::usage = "lhs =. removes any rules defined for lhs."
Update::usage = "Update[symbol] tells Mathematica that hidden changes have been made which could affect values associated with a symbol. Update[ ] specifies that the value of any symbol could be affected."
UpperCaseQ::usage = "UpperCaseQ[string] yields True if all the characters in the string are upper-case letters, and yields False otherwise."
UpSet::usage = "lhs^=rhs assigns rhs to be the value of lhs, and associates the assignment with symbols that occur at level one in lhs."
UpSetDelayed::usage = "lhs^:=rhs assigns rhs to be the delayed value of lhs, and associates the assignment with symbols that occur at level one in lhs."
UpValues::usage = "UpValues[f] gives a list of transformation rules corresponding to all upvalues defined for the symbol f."
$Urgent::usage = "$Urgent gives the list of files and pipes to which urgent output from Mathematica is sent."
Using::usage = "Using is an option to Roots that specifies any subsidiary equations that are to be used."
ValueForm::usage = "ValueForm is an internal symbol."
ValueList::usage = "ValueList is an internal symbol."
ValueQ::usage = "ValueQ[expr] gives True if a value has been defined for expr, and gives False otherwise."
ValueTable::usage = "ValueTable is an internal symbol."
Variables::usage = "Variables[expr] gives a list of all independent variables in a polynomial."
VectorQ::usage = "VectorQ[expr] gives True if expr is a list, none of whose elements are themselves lists, and gives False otherwise. VectorQ[expr, test] gives True only if test yields True when applied to each of the elements in expr."
VerifyConvergence::usage = "VerifyConvergence is an option to NSum and NProduct. VerifyConvergence -> True causes the limit of the terms and the limit of the ratio of the terms to be checked in the case of infinite sums and products. With VerifyConvergence -> False no checking is done."
VerifySolutions::usage = "VerifySolutions is an option to Solve and related functions. With VerifySolutions -> True, solutions are verified and extraneous solutions are eliminated. With VerifySolutions -> False, they are not. Note that only those solutions that are obviously extraneous are eliminated."
$Version::usage = "$Version is a string that represents the version of Mathematica you are running."
$VersionNumber::usage = "$VersionNumber is a real number which gives the current Mathematica kernel version number, and increases in successive versions."
VerticalForm::usage = "VerticalForm is an internal symbol used for formatting and printing."
ViewCenter::usage = "ViewCenter is an option for Graphics3D and SurfaceGraphics. With ViewCenter -> Automatic, the whole bounding box is centered in the final image area. With ViewCenter -> {x, y, z}, the point in the three-dimensional bounding box with scaled coordinates x, y, z is placed at the center of the final display area."
ViewPoint::usage = "ViewPoint is an option for Graphics3D and SurfaceGraphics which gives the point in space from which the objects plotted are to be viewed. ViewPoint -> {x, y, z} gives the position of the view point relative to the center of the three-dimensional box that contains the object being plotted."
ViewVertical::usage = "ViewVertical is an option for Graphics3D and SurfaceGraphics. ViewVertical -> {x, y, z} specifies the direction in scaled coordinates which should be vertical in the final image."
WeierstrassP::usage = "WeierstrassP[u, g2, g3] gives the Weierstrass elliptic function P."
WeierstrassPPrime::usage = "WeierstrassPPrime[u, g2, g3] gives the derivative with respect to u of the Weierstrass elliptic function P'."
Which::usage = "Which[test1, value1, test2, value2, ...] evaluates each of the testi in turn, returning the value of the valuei corresponding to the first one that yields True."
While::usage = "While[test, body] evaluates test, then body, repetitively, until test first fails to give True."
With::usage = "With[{x = x0, y = y0, ...}, expr] specifies that in expr occurrences of the symbols x, y, ... should be replaced by x0, y0, ...."
Word::usage = "Word represents a word in Read, Find and related functions."
WordSearch::usage = "WordSearch is an option for Find and FindList. With WordSearch -> True, the text searched for must appear as a word. With WordSearch -> False, it does not."
WordSeparators::usage = "WordSeparators is an option for Read, Find and related functions which specifies the list of strings to be taken as delimiters for words. The default setting is WordSeparators -> {\" \", \"\t\"}. WordSeparators -> {{lsep1, ... }, {rsep1, ... }} specifies different left and right separators for words."
WorkingPrecision::usage = "WorkingPrecision is an option for various numerical operations which specifies how many digits of precision should be maintained in internal computations. WorkingPrecision -> n causes all internal computations to be done to at most n-digit precision."
Write::usage = "Write[channel, expr1, expr2, ...] writes the expressions expri in sequence, followed by a newline, to the specified output channel."
WriteString::usage = "WriteString[channel, expr1, expr2, ...] converts the expri to strings, and then writes them in sequence to the specified output channel."
WynnDegree::usage = "WynnDegree is an option to SequenceLimit which specifies the degree of the algorithm. WynnDegree -> 1 gives Aitken's delta-squared algorithm. WynnDegree is also an option to NSum and NProduct, where it is passed to SequenceLimit for the extrapolation."
Xor::usage = "Xor[e1, e2, ...] is the logical XOR (exclusive OR) function. It gives True if an odd number of the ei are True, and the rest are False. It gives False if an even number of the ei are True, and the rest are False."
ZeroTest::usage = "ZeroTest is an option for LinearSolve and other linear algebra functions, which gives a function to be applied to combinations of matrix elements to determine whether or not they should be considered equal to zero."
Zeta::usage = "Zeta[s] gives the Riemann zeta function zeta(s). Zeta[s, a] gives the generalized Riemann zeta function."
CountRoots.m::usage = "For a given real polynomial f[x] and a given interval a <= x <= b, CountRoots computes the number of roots of f[x] within the given interval, using Sturm's method. "
Master.m::usage = " This file contains declarations of all the major symbols contained in files in this directory. When loaded, it sets up the symbols with attribute Stub, so the correct package will be loaded when the symbol is called. "
PolynomialMod.m::usage = " This package provides functions for doing polynomial arithemetic modulo a prime. PolynomialGCDMod, FactorMod, and FactorListMod extend the corresponding built-in functions to handle primes larger than 2^16. PolynomialQuotientMod and PolynomialRemainderMod generalize the corresponding built-in functions to modular arithmetic. PolynomialPowerMod efficiently computes powers of a polynomial modulo a prime and another polynomial. "
ReIm.m::usage = " This package provides a means for declaring a variable to be real and a function to be real for real arguments. It extends the built-in functions Re, Im, Abs, Conjugate, and Arg so that they make use of these real declarations. "
SymbolicSum.m::usage = "This package extends the built-in functions Sum and Product to accept symbolic limits. "
Trigonometry.m::usage = "This package provides trigonometric simplifications through the functions TrigReduce, TrigFactor, TrigToComplex, and ComplexToTrig. "
DSolveLog.m::usage = " This package handles the logarithmic case of linear ODEs with variable coefficients. It is an internal package used by Calculus`DSolve` and contains no public functions. "
Support.m::usage = "This package implements functions used in both Laplace and Fourier transforms. "
DiracDelta.m::usage = " This package defines the UnitStep function and its generalized derivative, DiracDelta. It extends Limit, Integrate, and Derivative to accept UnitStep and DiracDelta. "
DSolve.m::usage = " This package extends the built-in DSolve to compute differential equations of the hypergeometric type, selected nonlinear first/second order equations, and selected nonlinear systems of dimensions 2 and 3. "
EllipticIntegrate.m::usage = " This package extends the built-in Integrate to handle elliptic and related integrals. "
FourierTransform.m::usage = "This package implements exponential and trigonometric Fourier transforms and series. "
Limit.m::usage = " This package provides an enhancement to the built-in Limit. It allows one to find the limits of expressions containing elements of a wide class of elementary and special functions. "
Master.m::usage = " This file contains declarations of all the major symbols contained in files in this directory. When loaded, it sets up the symbols with attribute Stub, so the correct package will be loaded when the symbol is called. "
Pade.m::usage = " This package finds Pade approximations to functions at any point. In addition it finds economized rational approximations to functions over intervals. "
PDSolve1.m::usage = " This package extends the functionality of DSolve, enabling the function to handle first-order partial differential equations. "
VariationalMethods.m::usage = " This package finds first functional derivatives, Euler equations given the functional to be extremized, and the first integrals corresponding to energy or to ignorable coordinates. It also implements the Ritz variational procedure given a trial function. "
VectorAnalysis.m::usage = " This package performs standard vector differential operations in orthogonal coordinate systems. Coordinate transformations are also provided. "
CombinatorialFunctions.m::usage = " This package defines the functions CatalanNumber, Fibonacci, Hofstadter, and Subfactorial, used commonly in combinatorial analysis. "
CombinatorialSimplification.m::usage = " This package introduces elementary rules for simplifying ratios of factorials, products and binomial coefficients when the arguments are symbolic or non-numerical. "
Combinatorica.m::usage = " This package contains all the programs from the book, Implementing Discrete Mathematics: Combinatorics and Graph Theory with Mathematica, by Steven S. Skiena, Addison-Wesley Publishing Co., Advanced Book Program, 350 Bridge Parkway, Redwood City CA 94065. ISBN 0-201-50943-1. For ordering information, call 1-800-447-2226. "
ComputationalGeometry.m::usage = " This package implements selected functions from computational geometry relevent to nearest neighbor point location, including triangulation. "
Master.m::usage = " This file contains declarations of all the major symbols contained in files in this directory. When loaded, it sets up the symbols with attribute Stub, so the correct package will be loaded when the symbol is called. "
RSolve.m::usage = " This package provides the function RSolve plus other tools for solving recurrence (difference) equations. "
Tree.m::usage = " This package introduces functions for creating, searching and displaying trees represented as nested lists. "
CellularAutomata.m::usage = " This package includes some functions for working with one-dimensional cellular automata. "
Collatz.m::usage = " This package provides functions for studying the Collatz problem, also known as the 3x+1 problem. "
FileBrowse.m::usage = " This package introduces utilities for working with external files. "
IntegerRoots.m::usage = "This package provides a function for simplifying roots of integers. "
OptionUtilities.m::usage = "This package provides utilities for working with options. "
StringPatterns.m::usage = " This package implements a method of more general pattern matching with strings than the built-in * and @. "
Master.m::usage = " This file contains declarations of all the major symbols contained in files in this directory. When loaded, it sets up the symbols with attribute Stub, so the correct package will be loaded when the symbol is called. "
Polytopes.m::usage = " This package contains functions that give geometrical characteristics of regular polygons and polyhedra. "
Rotations.m::usage = " This package provides functions for rotating points in 2 and 3 dimensions. "
Animation.m::usage = " This package contains various animation functions for regular x-y, density, contour, and parametric curve plots. Animation of three-dimensional plots and rotation of two-dimensional plots is also supported. "
ArgColors.m::usage = "This package provides functions for specifying the color or gray level of graphics elements using the argument of a complex number. "
Arrow.m::usage = " This package introduces the Arrow[start, finish] graphics primitive and various style directives. "
Colors.m::usage = "This package contains functions that convert a color expressed in one of several color systems to an RGBColor. It also allows you to find the appropriate RGBColor for a particular color name (such as Blue). "
GraphicsCommon.m::usage = " This package defines symbols in a common context for use in graphics packages. "
ComplexMap.m::usage = "This package plots the images of Cartesian coordinate lines and polar coordinate lines under a user-supplied function f. "
ContourPlot3D.m::usage = " "
FilledPlot.m::usage = " This package allows one to fill the space between a plotted function and the x-axis or between a pair of plotted functions with a color. "
Graphics.m::usage = "This package provides special functions for plotting in two dimensions. Special formats include bar charts, pie charts, log plots, polar plots, and error bar plots. "
Graphics3D.m::usage = " This package provides special functions for plotting in three dimensions. Special formats include bar charts, scatter plots, surface plots, shadow plots, and projections. "
ImplicitPlot.m::usage = " The built-in function Plot requires one to specify an explicit function. Many simple graphs (e.g., circles, ellipses, etc.) are not functions. ImplicitPlot allows one to plot figures defined by equations. "
Legend.m::usage = " This package provides functions for placing a legend box on a graphic. It includes numerous options for specifying the legend and its placement. "
Master.m::usage = " This file contains declarations of all the major symbols contained in files in this directory. When loaded, it sets up the symbols with attribute Stub, so the correct package will be loaded when the symbol is called. "
MultipleListPlot.m::usage = "This package allows you to make list plots of several different lists using different symbols or line styles for points from each list. "
ParametricPlot3D.m::usage = "This package allows one to specify the step size of the grid used by ParametricPlot3D. In contrast, the built-in function ParametricPlot3D requires that the grid be specified using the option PlotPoints. The package also introduces the functions PointParametricPlot3D, SphericalPlot3D, and CylindricalPlot3D. "
PlotField.m::usage = "This package does plots of vector fields in the plane. PlotVectorField allows one to specify the functions describing the two components of the field. PlotGradientField and PlotHamiltonianField plot the respective vector fields associated with a scalar function. PlotPolyaField plots the field associated with a complex-valued function. ListPlotVectorField plots a rectangular array of vectors. "
PlotField3D.m::usage = " This package does plots of vector fields in three dimensions. PlotVectorField3D allows one to specify the functions describing the three components of the field. PlotGradientField3D plots the gradient vector field associated with a scalar function. ListPlotVectorField3D plots a three-dimensional array of vectors. "
Polyhedra.m::usage = "This package provides graphics primitives for rendering various Platonic polyhedra and functions for accessing the coordinates of the vertices and the vertex numbers of the faces. The package also includes functions for operating on polyhedra, such as Stellate, Geodesate, Truncate, and OpenTruncate. "
Shapes.m::usage = "This package provides lists of polygons for some common three-dimensional shapes. Functions for translating, rotating, and affine transforming Graphics3D objects and converting a Graphics3D object to its wire frame representation are also included. "
Spline.m::usage = " This package introduces a Spline graphics primitive and provides utilities for rendering splines. "
SurfaceOfRevolution.m::usage = " This package provides functions for plotting surfaces generated by revolving a curve about an axis. The curve may be expressed as a function, parametrically, or as a list of points. Rotation can be about an arbitrary axis. "
ThreeScript.m::usage = " This package provides a utility for converting three-dimensional graphical objects from Mathematica to the 3-Script file format and writing them into files (or suitable operating systems pipes). "
Cholesky.m::usage = "This package introduces the function CholeskyDecomposition. For a given symmetric positive definite matrix A, CholeskyDecomposition[A] returns an upper-triangular matrix U such that A = Transpose[U] . U. "
CrossProduct.m::usage = "This package introduces the cross product Cross for vectors in three dimensions. It also includes identities for vector cross products and dot products, where the vectors may be represented symbolically or using lists of components. "
GaussianElimination.m::usage = " This package implements LU decomposition with partial pivoting. It is not intended for computational purposes, but rather for educational purposes. This package can be used in conjunction with NumericalMath`ComputerArithmetic`. "
Master.m::usage = " This file contains declarations of all the major symbols contained in files in this directory. When loaded, it sets up the symbols with attribute Stub, so the correct package will be loaded when the symbol is called. "
MatrixManipulation.m::usage = "This package provides basic matrix manipulation routines for composing a matrix from block elements and extracting subblocks from a matrix. Included are functions for generating special matrices such as Hilbert and Hankel. "
Orthogonalization.m::usage = " This package provides the Gram-Schmidt routine for orthogonalizing a list of vectors or a list of functions. "
Tridiagonal.m::usage = "TridiagonalSolve solves A . x == r for x, where A is an n x n tridiagonal matrix and r is a vector of length n. "
Audio.m::usage = "This package provides functions for the manipulation and synthesis of sounds. "
Calendar.m::usage = "This package provides functions for basic calendar operations. The Gregorian, Julian, and Islamic calendars are supported. "
ChemicalElements.m::usage = " This package provides functions giving basic properties of the chemical elements. Properties include atomic number, atomic weight, melting and boiling points, heat of fusion, heat of vaporization, density, thermal conductivity, and electron configuration. "
CityData.m::usage = " This package provides a database for information about cities. It is also a useful model of a database in Mathematica. "
Geodesy.m::usage = " This package contains functions useful for or derived from geodesy, the science of measuring and mapping the surface of the Earth. For instance, the package includes functions for finding the distance between two points on the surface of the planet, using different models. "
Master.m::usage = " This file contains declarations of all the major symbols contained in files in this directory. When loaded, it sets up the symbols with attribute Stub, so the correct package will be loaded when the symbol is called. "
Music.m::usage = "This package provides functions for the manipulation and synthesis of scales. It includes pitch/frequency equivalents. "
PhysicalConstants.m::usage = " This package provides the values of various commonly used physical constants. "
SIUnits.m::usage = " This package introduces base SI and derived SI units. (SI stands for the International System of units). "
Units.m::usage = " This package provides functions for conversion between units. It also provides additional units beyond base SI units and derived SI units found in Miscellaneous`SIUnits`. "
WorldData.m::usage = " This package defines polygons corresponding to maps of countries listed in the Miscellaneous`WorldNames` package, for use with the Miscellaneous`WorldPlot` package. Each country is made up of a list of lists of coordinates (of the form {lat, long} in minutes) that form the borders of that country."
WorldNames.m::usage = " This package defines symbols for use with the Miscellaneous`WorldPlot` package at the global level. The symbols are the names of countries and lists of countries. The defined lists are World, NorthAmerica, Europe, SouthAmerica, Asia, Oceania, Africa. "
WorldPlot.m::usage = " This package allows one to plot graphic objects, where positions are expressed in terms of latitute and longitude (i.e., maps). A number of standard map projections are supported. Loading the package will also load data describing the names and outlines of countries of the world. "
Binomial.m::usage = "This package allows one to compute the binomial, the factorial, and the binomial modulo a prime. The computation is more efficient than the respective built-in functions for large arguments. "
ContinuedFractions.m::usage = "This package provides a function for computing the continued fraction expansion of a real number. "
FactorIntegerECM.m::usage = " This package provides a function for finding a single factor of a composite number using Lenstra's elliptic curve method. "
Master.m::usage = " This file contains declarations of all the major symbols contained in files in this directory. When loaded, it sets up the symbols with attribute Stub, so the correct package will be loaded when the symbol is called. "
NumberTheoryFunctions.m::usage = "This package implements some standard functions from number theory. "
PrimeQ.m::usage = "This package implements primality proving. The functions provided in this package not only prove primality, but they also generate a certificate of primality (i.e., a relatively short set of data that makes the primality proof easy). "
Ramanujan.m::usage = " This package evaluates Ramanujan's tau function, Ramanujan's tau-Dirichlet series, and a related function that is real along the critical line. "
Rationalize.m::usage = "The built-in function Rationalize gives a rational approximation to a single real number. The functions provided by this package give a list of rational numbers that approximate a list of real numbers. The approximation is simultaneous and preserves the relationships among the given numbers. "
Recognize.m::usage = "This package allows you to find the minimal polynomial of which a given approximate number is a root. "
Approximations.m::usage = "This package provides tools for finding a rational approximation to a differentiable function. The approximation may be an interpolation between specified abscissas or a minimax approximation over an interval. The function may be specified explicitly or parametrically. "
BesselZeros.m::usage = " This package provides functions which find the zeros of Bessel functions. "
Butcher.m::usage = " This package gives the order conditions which any Runge-Kutta method must satisfy to be of any particular order. It works for both implicit and explicit methods. The package also gives Butcher trees and implements the functions Phi and gamma. "
CauchyPrincipalValue.m::usage = "This package introces a function for numerically evaluating Cauchy principal values of integrals that may not be Riemann integrable. The built-in function NIntegrate is used in a symmetric way to get cancelation. "
ComputerArithmetic.m::usage = " This package implements fixed precision, rounded arithmetic. The arithmetic can be in any base from 2 to 16, and any of several rounding schemes can be used. The range of the exponent can also be varied within limits. This package is not suitable for computational purposes; it is much too slow. Its real use is educational, but it can be used in conjunction with other packages such as LinearAlgebra`GaussianElimination`. "
GaussianQuadrature.m::usage = " This package calculates the weights and abscissas for the elementary Gaussian quadrature rule with n points on the interval a to b. It also calculates the error in the elementary Gaussian quadrature formula with n points on the interval a to b. "
InterpolateRoot.m::usage = "This package numerically finds a root of an analytic function of a single variable using at each iteration every bit of known information about the function. It is particularly useful when each evaluation of the function is extremely expensive and extremely high precision is desired. "
IntervalAnalysis.m::usage = " This package implements rigorous, outward-rounded interval arithmetic, which can be used for proving bounds. However, this package is obsolete and is superseded by the kernel function Interval and its related functions. "
IntervalArithmetic.m::usage = " This package implements a simple form of interval arithmetic in which the endpoints of the intervals are calculated correctly, but with standard machine-precision arithmetic. In particular, no effort is made to round results outward. It is not intended for rigorous calculation, but rather for educational purposes. The kernel function Interval and related functions have rendered this package obsolete. "
ListIntegrate.m::usage = " Given a function in the form of a sorted list of ordered pairs (or simply as a list of ordinates, assuming equally spaced abscissas), ListIntegrate gives an approximation to the definite integral of that function from the first to the last abscissa. "
Master.m::usage = " This file contains declarations of all the major symbols contained in files in this directory. When loaded, it sets up the symbols with attribute Stub, so the correct package will be loaded when the symbol is called. "
Microscope.m::usage = " This package allows functions to be plotted on a microscopic scale to exhibit the granularity of machine arithmetic. Alternatively the actual error (measured in ulps (units last place)) can be plotted. "
NewtonCotes.m::usage = " This package finds weights and abscissas for Newton-Cotes quadrature formulas of arbitrary order. Both open and closed formulas are supported. "
NLimit.m::usage = " This package evaluates numerical limits by forming a short sequence of function values corresponding to different values of the limit variable. This sequence is passed to SequenceLimit, or Euler's transformation is used to find an approximation to the limit. Numerical sums are evaluated using Euler's transformation rather than using NSum. Numerical differentiation is implemented using Richardson extrapolation via Euler's transformation. "
PolynomialFit.m::usage = " This package does polynomial least squares fitting of data and avoids the numerical instability that often results if the basis functions are chosen to be simple powers of a variable. Shifted Chebyshev polynomials of the first kind are used as a basis for the vector space of polynomials in a single variable. The shift is chosen based on the distribution of the abscissas of the data. The result is returned as a pure function, partly for convenience and partly to discourage the user from trying to rewrite it as a linear combination of simple powers. Such "simplification" would destroy much of the numerical stability gained by this method. "
SplineFit.m::usage = " This package introduces the SplineFunction object and a fitting function to generate it, for curve fitting with splines. "
ComplexMap.m::usage = "This package plots the images of cartesian coordinate lines and polar coordinate lines under a user supplied function f. "
ParametricPlot3D.m::usage = ""
SphericalCurve.m::usage = "This package plots a 3D parametric curve given in spherical coordinates. "
ClebschGordan.m::usage = " This package computes the Clebsch Gordan, 3-j coefficients (Wigner), and 6-j coefficients (Wigner) for both numeric and symbolic arguments. "
Elliptic.m::usage = " Extends the coverage of elliptic functions from that in the kernel to include the Jacobi elliptic functions and their inverses, the Neville theta functions, the amplitude function am, the nome function q, and the Weierstrass P function and its derivative. "
Gamma.m::usage = " This package allows to simplify any expressions with Gamma-functions using a sequence of 8 rules which apply to the expression. "
HypergeometricPFQ.m::usage = " Provides rules for evaluating generalized hypergeometric and regularized hypergeometric functions. "
PolyGamma.m::usage = " This package allows to simplify any expressions with PolyGamma-functions using a sequence of 10 rules which apply to the expression. "
Series.m::usage = " Defines InverseSeries[ ] using Newton's method symbolically. Provides series of special functions using special properties of those functions. Also allows series expansions of special functions about singularities of certain simple types. "
DistributionsCommon.m::usage = " This package defines functions and introduces symbols in a common context for use in statistical probability distribution packages. "
FitCommon.m::usage = " This package defines symbols in a common context for use in statistical fitting packages. "
HypothesisCommon.m::usage = " This package contains usage messages for option names used by both Statistics`ConfidenceIntervals` and Statistics`HypothesisTests`. "
ConfidenceIntervals.m::usage = " This package provides confidence intervals for elementary reference distributions derived from the normal distribution. Distributions represented are NormalDistribution, StudentTDistribution, ChiSquareDistribution, and FRatioDistribution. "
ContinuousDistributions.m::usage = " This package provides properties and functionals of continuous probability distributions used in statistical computations. "
DataManipulation.m::usage = " This package provides an extension of the list manipulation functions that are built-in to Mathematica. Additional functions useful for manipulating statistical data include frequency counting and computing cumulative sums. "
DescriptiveStatistics.m::usage = " This package computes descriptive statistics (location, dispersion, and shape statistics) for samples represented by lists. "
DiscreteDistributions.m::usage = " This package provides properties and functionals of discrete probability distributions used in statistical computations. "
HypothesisTests.m::usage = " This package provides hypothesis tests based on elementary distributions derived from the normal distribution. Distributions represented are NormalDistribution, StudentTDistribution, ChiSquareDistribution, and FRatioDistribution. "
InverseStatisticalFunctions.m::usage = " This Package defines the inverses of the following statistical functions: Erf, Erfc, GammaRegularized, and BetaRegularized. The algorithms are similar to Newton's method except that, rather than using a linear approximation, higher-order approximations are used leading to cubic, and in the case of InverseErf, quartic convergence. "
LinearRegression.m::usage = " This package provides least squares or weighted least squares linear regression for data whose errors are assumed to be normally and independently distributed. It supports a number of commonly used statistics such as RSquared, EstimatedVariance, and an ANOVATable. "
Master.m::usage = " This file contains declarations of all the major symbols contained in files in this directory. When loaded, it sets up the symbols with attribute Stub, so the correct package will be loaded when the symbol is called. "
MovingAverage.m::usage = " This package provides a function for applying a moving average to a list of data, resulting in a list of means. "
NonlinearFit.m::usage = " This package performs nonlinear least squares curve fitting using a variety of algorithms. "
NormalDistribution.m::usage = " This package provides properties and functionals of the four standard probability distributions derived from the normal (Gaussian) distribution. The four distributions are the normal distribution, Student's t-distribution, the chi-square distribution, and the F-ratio distribution. "
BinaryFiles.m::usage = " This package provides functions for opening, reading, and writing files containing binary data. "
DXF.m::usage = " This package allows the export of Graphics3D objects to a file in the AutoCAD DXF format. "
FilterOptions.m::usage = " This package provides a function for selecting valid options when passing options from one function to another. "
Language.m::usage = " This package adds definitions for $Letters and $StringOrder which are appropriate for a number of European languages which can be represented by 8-bit characters in the the ISOLatin1 standard. These are arranged for a variety of different font encodings such as ISOLatin1, Macintosh and DOS. It also defines the function CharacterTable, which displays a table of octal codes and their corresponding codes. "
Master.m::usage = " This file contains declarations of all the major symbols contained in files in this directory. When loaded, it sets up the symbols with attribute Stub, so the correct package will be loaded when the symbol is called. "
MemoryConserve.m::usage = " This package implements automatic calls to Share[] when MemoryInUse[] has increased by a set amount. Sharing the storage of common subexpressions may reduce the amount of memory which has been used so far in the session. "
Package.m::usage = " This package provides various utilities for searching and working with Mathematica packages. "
ShowTime.m::usage = " This package provides a utility to print timing information for each evaluation. "
